Merge inbound to mozilla-central. a=merge
authorBrindusan Cristian <cbrindusan@mozilla.com>
Thu, 25 Apr 2019 00:54:01 +0300
changeset 471176 c7a9affeb6046ef5688e024360da6dd2dc5da358
parent 470704 b9a625eff9e301f700196de977f916e7f77a895f (current diff)
parent 471175 5d7b8187380f831c386018fc9f0c8add93d700c1 (diff)
child 471216 d428c2d08e38eb7a05a25e0c603c90745e1427cb
child 471268 769c9790263d7cb6b1a350fd60967b88cff8f0f4
push id35911
push usercbrindusan@mozilla.com
push dateWed, 24 Apr 2019 21:55:25 +0000
treeherdermozilla-central@c7a9affeb604 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone68.0a1
first release with
nightly linux32
c7a9affeb604 / 68.0a1 / 20190424215525 / files
nightly linux64
c7a9affeb604 / 68.0a1 / 20190424215525 / files
nightly mac
c7a9affeb604 / 68.0a1 / 20190424215525 / files
nightly win32
c7a9affeb604 / 68.0a1 / 20190424215525 / files
nightly win64
c7a9affeb604 / 68.0a1 / 20190424215525 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
.cargo/config.in
Cargo.lock
Cargo.toml
browser/base/content/browser.js
docshell/base/nsDocShell.cpp
dom/base/InProcessTabChildMessageManager.cpp
dom/base/InProcessTabChildMessageManager.h
dom/indexedDB/ActorsParent.cpp
dom/interfaces/base/nsITabChild.idl
dom/interfaces/base/nsITabParent.idl
dom/ipc/BrowserParent.cpp
dom/ipc/ContentParent.cpp
dom/ipc/TabChild.cpp
dom/ipc/TabChild.h
dom/ipc/TabParent.cpp
dom/ipc/TabParent.h
dom/ipc/moz.build
gfx/layers/apz/src/APZCTreeManager.cpp
js/src/builtin/TestingFunctions.cpp
js/src/shell/js.cpp
js/src/wasm/cranelift/src/compile.rs
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpChannel.h
testing/web-platform/meta/css/css-flexbox/intrinsic-width-overflow-auto.tentative.html.ini
testing/web-platform/meta/css/css-text/white-space/pre-wrap-016.html.ini
testing/web-platform/meta/feature-policy/reporting/legacy-image-formats-reporting.html.ini
testing/web-platform/meta/feature-policy/reporting/unoptimized-images-reporting-onload.html.ini
testing/web-platform/meta/feature-policy/reporting/unoptimized-images-reporting.html.ini
testing/web-platform/meta/html/semantics/embedded-content/media-elements/track/track-element/track-cue-rendering-line-doesnt-fit.html.ini
testing/web-platform/meta/infrastructure/reftest/reftest_fuzzy.html.ini
testing/web-platform/meta/payment-request/payment-request-hasenrolledinstrument-method-protection.https.html.ini
testing/web-platform/meta/payment-request/payment-request-hasenrolledinstrument-method.https.html.ini
testing/web-platform/meta/preload/dynamic-adding-preload-imagesrcset.tentative.html.ini
testing/web-platform/meta/preload/link-header-preload-srcset.tentative.html.ini
testing/web-platform/meta/trusted-types/__dir__.ini
testing/web-platform/meta/webrtc/RTCPeerConnection-connectionState.html.ini
testing/web-platform/tests/.travis.yml
testing/web-platform/tests/annotation-model/annotations/.gitignore
testing/web-platform/tests/annotation-model/annotations/bodiesTargets/.gitignore
testing/web-platform/tests/annotation-model/collections/.gitignore
testing/web-platform/tests/annotation-model/definitions/.gitignore
testing/web-platform/tests/annotation-protocol/server/.gitignore
testing/web-platform/tests/annotation-vocab/tools/.gitignore
testing/web-platform/tests/clipboard-apis/async-write-duplicate-mime-type-manual.https.html
testing/web-platform/tests/conformance-checkers/.gitignore
testing/web-platform/tests/cors/resources/.gitignore
testing/web-platform/tests/css/.gitignore
testing/web-platform/tests/css/css-flexbox/interactive/flexbox_interactive_paged-overflow-2.html
testing/web-platform/tests/css/css-flexbox/interactive/flexbox_interactive_paged-overflow.html
testing/web-platform/tests/css/css-flexbox/intrinsic-width-overflow-auto.tentative.html
testing/web-platform/tests/css/css-rhythm/tools/generators/.gitignore
testing/web-platform/tests/css/css-writing-modes/tools/generators/.gitignore
testing/web-platform/tests/eventsource/format-field-id-null.htm
testing/web-platform/tests/feature-policy/reporting/legacy-image-formats-reporting.html
testing/web-platform/tests/feature-policy/reporting/legacy-image-formats-reporting.html.headers
testing/web-platform/tests/feature-policy/reporting/unoptimized-images-reporting-onload.html
testing/web-platform/tests/feature-policy/reporting/unoptimized-images-reporting-onload.html.headers
testing/web-platform/tests/feature-policy/reporting/unoptimized-images-reporting.html
testing/web-platform/tests/feature-policy/reporting/unoptimized-images-reporting.html.headers
testing/web-platform/tests/html/form-elements/the-textarea-element/multiline-placeholder-cr.html
testing/web-platform/tests/html/form-elements/the-textarea-element/multiline-placeholder-crlf.html
testing/web-platform/tests/html/form-elements/the-textarea-element/multiline-placeholder-ref.html
testing/web-platform/tests/html/form-elements/the-textarea-element/multiline-placeholder.html
testing/web-platform/tests/html/form-elements/the-textarea-element/support/placeholder.css
testing/web-platform/tests/html/scripting/the-noscript-element/non-html-noscript.html
testing/web-platform/tests/interfaces/ResizeObserver.idl
testing/web-platform/tests/orientation-event/free-fall-manual.html
testing/web-platform/tests/orientation-event/horizontal-surface-manual.html
testing/web-platform/tests/orientation-event/screen-upmost-manual.html
testing/web-platform/tests/orientation-event/screen-upright-manual.html
testing/web-platform/tests/orientation-event/t001-manual.html
testing/web-platform/tests/orientation-event/t002-manual.html
testing/web-platform/tests/orientation-event/t003-manual.html
testing/web-platform/tests/orientation-event/t006-manual.html
testing/web-platform/tests/orientation-event/t009-manual.html
testing/web-platform/tests/orientation-event/t010-manual.html
testing/web-platform/tests/orientation-event/t012-manual.html
testing/web-platform/tests/orientation-event/t021-manual.html
testing/web-platform/tests/orientation-event/t022-manual.html
testing/web-platform/tests/orientation-event/t023-manual.html
testing/web-platform/tests/orientation-event/t025-manual.html
testing/web-platform/tests/orientation-event/t028-manual.html
testing/web-platform/tests/payment-request/payment-request-hasenrolledinstrument-method-manual.https.html
testing/web-platform/tests/payment-request/payment-request-hasenrolledinstrument-method-protection.https.html
testing/web-platform/tests/payment-request/payment-request-hasenrolledinstrument-method.https.html
testing/web-platform/tests/pointerevents/pointerevent_change-touch-action-onpointerdown_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_pointercancel_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_pointerleave_after_pointercancel_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_pointerout_after_pointercancel_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_releasepointercapture_onpointercancel_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_touch-action-auto-css_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_touch-action-inherit_highest-parent-none_touch-manual.html
testing/web-platform/tests/pointerevents/pointerevent_touch-action-pan-x-pan-y_touch-manual.html
testing/web-platform/tests/preload/dynamic-adding-preload-imagesrcset.tentative.html
testing/web-platform/tests/preload/link-header-preload-srcset.tentative.html
testing/web-platform/tests/preload/link-header-preload-srcset.tentative.html.headers
testing/web-platform/tests/resources/.gitignore
testing/web-platform/tests/tools/ci/before_install.sh
testing/web-platform/tests/tools/ci/ci_manifest.sh
testing/web-platform/tests/tools/ci/install.sh
testing/web-platform/tests/tools/ci/lib.sh
testing/web-platform/tests/tools/ci/run.sh
testing/web-platform/tests/tools/ci/start.sh
testing/web-platform/tests/webaudio/.gitignore
testing/web-platform/tests/webrtc/RTCPeerConnection-connectionState.html
third_party/rust/cranelift-codegen-meta/.cargo-checksum.json
third_party/rust/cranelift-codegen-meta/src/lib.rs
third_party/rust/cranelift-codegen/.cargo-checksum.json
third_party/rust/cranelift-codegen/meta-python/build.py
third_party/rust/cranelift-codegen/meta-python/gen_instr.py
third_party/rust/cranelift-codegen/meta-python/gen_legalizer.py
third_party/rust/cranelift-codegen/src/context.rs
third_party/rust/cranelift-codegen/src/simple_preopt.rs
third_party/rust/cranelift-codegen/src/verifier/mod.rs
toolkit/components/passwordmgr/test/mochitest/test_tooshort_username.html
--- a/.cargo/config.in
+++ b/.cargo/config.in
@@ -19,13 +19,13 @@ replace-with = "vendored-sources"
 
 [source."https://github.com/rust-lang-nursery/packed_simd"]
 git = "https://github.com/hsivonen/packed_simd"
 branch = "rust_1_32"
 replace-with = "vendored-sources"
 
 [source."https://github.com/CraneStation/Cranelift"]
 git = "https://github.com/CraneStation/Cranelift"
-rev = "542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
+rev = "538a0662bf90a1daa9921c10f34827ace134abf1"
 replace-with = "vendored-sources"
 
 [source.vendored-sources]
 directory = '@top_srcdir@/third_party/rust'
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -161,18 +161,18 @@ dependencies = [
  "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "baldrdash"
 version = "0.1.0"
 dependencies = [
  "bindgen 0.49.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
- "cranelift-wasm 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+ "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
+ "cranelift-wasm 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
  "env_logger 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "base64"
 version = "0.9.3"
@@ -573,67 +573,67 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "cose 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-bforest"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
-dependencies = [
- "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
+dependencies = [
+ "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
 ]
 
 [[package]]
 name = "cranelift-codegen"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
-dependencies = [
- "cranelift-bforest 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
- "cranelift-codegen-meta 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
- "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
+dependencies = [
+ "cranelift-bforest 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
+ "cranelift-codegen-meta 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
+ "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
  "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
-dependencies = [
- "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
+dependencies = [
+ "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
 ]
 
 [[package]]
 name = "cranelift-entity"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
 
 [[package]]
 name = "cranelift-frontend"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
-dependencies = [
- "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
+dependencies = [
+ "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cranelift-wasm"
 version = "0.30.0"
-source = "git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee#542d799dd7a3b2cc15b91eefdcd85cace8fe5cee"
+source = "git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1#538a0662bf90a1daa9921c10f34827ace134abf1"
 dependencies = [
  "cast 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
- "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
- "cranelift-frontend 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)",
+ "cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
+ "cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
+ "cranelift-frontend 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)",
  "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "wasmparser 0.29.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "crc"
@@ -3517,22 +3517,22 @@ dependencies = [
 "checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
 "checksum cookie 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1465f8134efa296b4c19db34d909637cb2bf0f7aaf21299e23e18fa29ac557cf"
 "checksum core-foundation 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4e2640d6d0bf22e82bed1b73c6aef8d5dd31e5abe6666c57e6d45e2649f4f887"
 "checksum core-foundation-sys 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
 "checksum core-graphics 0.17.1 (registry+https://github.com/rust-lang/crates.io-index)" = "62ceafe1622ffc9a332199096841d0ff9912ec8cf8f9cde01e254a7d5217cd10"
 "checksum core-text 13.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f3f46450d6f2397261af420b4ccce23807add2e45fa206410a03d66fb7f050ae"
 "checksum cose 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "72fa26cb151d3ae4b70f63d67d0fed57ce04220feafafbae7f503bef7aae590d"
 "checksum cose-c 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "49726015ab0ca765144fcca61e4a7a543a16b795a777fa53f554da2fffff9a94"
-"checksum cranelift-bforest 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
-"checksum cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
-"checksum cranelift-codegen-meta 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
-"checksum cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
-"checksum cranelift-frontend 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
-"checksum cranelift-wasm 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=542d799dd7a3b2cc15b91eefdcd85cace8fe5cee)" = "<none>"
+"checksum cranelift-bforest 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
+"checksum cranelift-codegen 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
+"checksum cranelift-codegen-meta 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
+"checksum cranelift-entity 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
+"checksum cranelift-frontend 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
+"checksum cranelift-wasm 0.30.0 (git+https://github.com/CraneStation/Cranelift?rev=538a0662bf90a1daa9921c10f34827ace134abf1)" = "<none>"
 "checksum crc 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd5d02c0aac6bd68393ed69e00bbc2457f3e89075c6349db7189618dc4ddc1d7"
 "checksum crossbeam-deque 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f739f8c5363aca78cfb059edf753d8f0d36908c348f3d8d1503f03d8b75d9cf3"
 "checksum crossbeam-deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fe8153ef04a7594ded05b427ffad46ddeaf22e63fd48d42b3e1e3bb4db07cae7"
 "checksum crossbeam-epoch 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "927121f5407de9956180ff5e936fe3cf4324279280001cd56b669d28ee7e9150"
 "checksum crossbeam-epoch 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2af0e75710d6181e234c8ecc79f14a97907850a541b13b0be1dd10992f2e4620"
 "checksum crossbeam-utils 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "2760899e32a1d58d5abb31129f8fae5de75220bc2176e77ff7c627ae45c918d9"
 "checksum crossbeam-utils 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d636a8b3bcc1b409d7ffd3facef8f21dcb4009626adbd0c5e6c4305c07253c7b"
 "checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,10 +56,16 @@ debug-assertions = false
 panic = "abort"
 codegen-units = 1
 
 [patch.crates-io]
 libudev-sys = { path = "dom/webauthn/libudev-sys" }
 serde_derive = { git = "https://github.com/servo/serde", branch = "deserialize_from_enums10" }
 winapi = { git = "https://github.com/froydnj/winapi-rs", branch = "aarch64" }
 packed_simd = { git = "https://github.com/hsivonen/packed_simd", branch = "rust_1_32" }
-cranelift-codegen = { git = "https://github.com/CraneStation/Cranelift", rev = "542d799dd7a3b2cc15b91eefdcd85cace8fe5cee" }
-cranelift-wasm = { git = "https://github.com/CraneStation/Cranelift", rev = "542d799dd7a3b2cc15b91eefdcd85cace8fe5cee" }
+
+[patch.crates-io.cranelift-codegen]
+git = "https://github.com/CraneStation/Cranelift"
+rev = "538a0662bf90a1daa9921c10f34827ace134abf1"
+
+[patch.crates-io.cranelift-wasm]
+git = "https://github.com/CraneStation/Cranelift"
+rev = "538a0662bf90a1daa9921c10f34827ace134abf1"
--- a/accessible/android/SessionAccessibility.cpp
+++ b/accessible/android/SessionAccessibility.cpp
@@ -11,17 +11,17 @@
 #include "HyperTextAccessible.h"
 #include "JavaBuiltins.h"
 #include "RootAccessibleWrap.h"
 #include "nsAccessibilityService.h"
 #include "nsViewManager.h"
 #include "nsIPersistentProperties2.h"
 
 #include "mozilla/PresShell.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/a11y/DocManager.h"
 
 #ifdef DEBUG
 #  include <android/log.h>
 #  define AALOG(args...) \
     __android_log_print(ANDROID_LOG_INFO, "GeckoAccessibilityNative", ##args)
 #else
@@ -115,17 +115,18 @@ void SessionAccessibility::Click(int32_t
     }
 
     acc->DoAction(0);
   }
 }
 
 SessionAccessibility* SessionAccessibility::GetInstanceFor(
     ProxyAccessible* aAccessible) {
-  auto tab = static_cast<dom::TabParent*>(aAccessible->Document()->Manager());
+  auto tab =
+      static_cast<dom::BrowserParent*>(aAccessible->Document()->Manager());
   dom::Element* frame = tab->GetOwnerElement();
   MOZ_ASSERT(frame);
   if (!frame) {
     return nullptr;
   }
 
   Accessible* chromeDoc = GetExistingDocAccessible(frame->OwnerDoc());
   return chromeDoc ? GetInstanceFor(chromeDoc) : nullptr;
--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -28,17 +28,17 @@
 #include "nsDocShellLoadTypes.h"
 #include "nsIChannel.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIWebNavigation.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIWebProgress.h"
 #include "nsCoreUtils.h"
 #include "nsXULAppAPI.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 using namespace mozilla::dom;
 
 StaticAutoPtr<nsTArray<DocAccessibleParent*>> DocManager::sRemoteDocuments;
 nsRefPtrHashtable<nsPtrHashKey<const DocAccessibleParent>,
                   xpcAccessibleDocument>* DocManager::sRemoteXPCDocumentCache =
--- a/accessible/base/FocusManager.cpp
+++ b/accessible/base/FocusManager.cpp
@@ -12,17 +12,17 @@
 #include "nsEventShell.h"
 #include "Role.h"
 
 #include "nsFocusManager.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/a11y/DocManager.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 
 namespace mozilla {
 namespace a11y {
 
 FocusManager::FocusManager() {}
 
 FocusManager::~FocusManager() {}
 
@@ -171,17 +171,17 @@ void FocusManager::ActiveItemChanged(Acc
   // If mActiveItem is null we may need to shift a11y focus back to a tab
   // document. For example, when combobox popup is closed, then
   // the focus should be moved back to the combobox.
   if (!mActiveItem && XRE_IsParentProcess()) {
     nsFocusManager* domfm = nsFocusManager::GetFocusManager();
     if (domfm) {
       nsIContent* focusedElm = domfm->GetFocusedElement();
       if (EventStateManager::IsRemoteTarget(focusedElm)) {
-        dom::TabParent* tab = dom::TabParent::GetFrom(focusedElm);
+        dom::BrowserParent* tab = dom::BrowserParent::GetFrom(focusedElm);
         if (tab) {
           a11y::DocAccessibleParent* dap = tab->GetTopLevelDocAccessible();
           if (dap) {
             Unused << dap->SendRestoreFocus();
           }
         }
       }
     }
--- a/accessible/base/NotificationController.cpp
+++ b/accessible/base/NotificationController.cpp
@@ -6,17 +6,17 @@
 #include "NotificationController.h"
 
 #include "DocAccessible-inl.h"
 #include "DocAccessibleChild.h"
 #include "nsEventShell.h"
 #include "TextLeafAccessible.h"
 #include "TextUpdater.h"
 
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/Telemetry.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 using namespace mozilla::dom;
 
@@ -915,20 +915,20 @@ void NotificationController::WillRefresh
 
       ipcDoc = new DocAccessibleChild(childDoc, parentIPCDoc->Manager());
       childDoc->SetIPCDoc(ipcDoc);
 
 #if defined(XP_WIN)
       parentIPCDoc->ConstructChildDocInParentProcess(
           ipcDoc, id, AccessibleWrap::GetChildIDFor(childDoc));
 #else
-      nsCOMPtr<nsITabChild> tabChild =
+      nsCOMPtr<nsIBrowserChild> browserChild =
           do_GetInterface(mDocument->DocumentNode()->GetDocShell());
-      if (tabChild) {
-        static_cast<TabChild*>(tabChild.get())
+      if (browserChild) {
+        static_cast<BrowserChild*>(browserChild.get())
             ->SendPDocAccessibleConstructor(ipcDoc, parentIPCDoc, id, 0, 0);
       }
 #endif
     }
   }
 
   mObservingState = eRefreshObserving;
   if (!mDocument) return;
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -39,17 +39,17 @@
 #include "nsFocusManager.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/HTMLEditor.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/TextEditor.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/DocumentType.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/MutationEventBinding.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1354,36 +1354,37 @@ void DocAccessible::NotifyOfLoading(bool
   FireDelayedEvent(stateEvent);
 }
 
 void DocAccessible::DoInitialUpdate() {
   if (nsCoreUtils::IsTabDocument(mDocumentNode)) {
     mDocFlags |= eTabDocument;
     if (IPCAccessibilityActive()) {
       nsIDocShell* docShell = mDocumentNode->GetDocShell();
-      if (RefPtr<dom::TabChild> tabChild = dom::TabChild::GetFrom(docShell)) {
+      if (RefPtr<dom::BrowserChild> browserChild =
+              dom::BrowserChild::GetFrom(docShell)) {
         DocAccessibleChild* ipcDoc = IPCDoc();
         if (!ipcDoc) {
-          ipcDoc = new DocAccessibleChild(this, tabChild);
+          ipcDoc = new DocAccessibleChild(this, browserChild);
           SetIPCDoc(ipcDoc);
 
 #if defined(XP_WIN)
           IAccessibleHolder holder(
               CreateHolderFromAccessible(WrapNotNull(this)));
           MOZ_ASSERT(!holder.IsNull());
           int32_t childID = AccessibleWrap::GetChildIDFor(this);
 #else
           int32_t holder = 0, childID = 0;
 #endif
-          tabChild->SendPDocAccessibleConstructor(ipcDoc, nullptr, 0, childID,
-                                                  holder);
+          browserChild->SendPDocAccessibleConstructor(ipcDoc, nullptr, 0,
+                                                      childID, holder);
         }
 
         if (IsRoot()) {
-          tabChild->SetTopLevelDocAccessibleChild(ipcDoc);
+          browserChild->SetTopLevelDocAccessibleChild(ipcDoc);
         }
       }
     }
   }
 
   mLoadState |= eTreeConstructed;
 
   // Set up a root element and ARIA role mapping.
--- a/accessible/generic/OuterDocAccessible.cpp
+++ b/accessible/generic/OuterDocAccessible.cpp
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "OuterDocAccessible.h"
 
 #include "Accessible-inl.h"
 #include "nsAccUtils.h"
 #include "DocAccessible-inl.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "Role.h"
 #include "States.h"
 
 #ifdef A11Y_LOG
 #  include "Logging.h"
 #endif
 
 using namespace mozilla;
@@ -180,13 +180,13 @@ Accessible* OuterDocAccessible::GetChild
     return nullptr;
   }
   return WrapperFor(remoteChild);
 }
 
 #endif  // defined(XP_WIN)
 
 DocAccessibleParent* OuterDocAccessible::RemoteChildDoc() const {
-  dom::TabParent* tab = dom::TabParent::GetFrom(GetContent());
+  dom::BrowserParent* tab = dom::BrowserParent::GetFrom(GetContent());
   if (!tab) return nullptr;
 
   return tab->GetTopLevelDocAccessible();
 }
--- a/accessible/generic/RootAccessible.cpp
+++ b/accessible/generic/RootAccessible.cpp
@@ -664,17 +664,17 @@ void RootAccessible::HandleTreeInvalidat
 }
 #endif
 
 ProxyAccessible* RootAccessible::GetPrimaryRemoteTopLevelContentDoc() const {
   nsCOMPtr<nsIDocShellTreeOwner> owner;
   mDocumentNode->GetDocShell()->GetTreeOwner(getter_AddRefs(owner));
   NS_ENSURE_TRUE(owner, nullptr);
 
-  nsCOMPtr<nsITabParent> tabParent;
-  owner->GetPrimaryTabParent(getter_AddRefs(tabParent));
-  if (!tabParent) {
+  nsCOMPtr<nsIRemoteTab> browserParent;
+  owner->GetPrimaryRemoteTab(getter_AddRefs(browserParent));
+  if (!browserParent) {
     return nullptr;
   }
 
-  auto tab = static_cast<dom::TabParent*>(tabParent.get());
+  auto tab = static_cast<dom::BrowserParent*>(browserParent.get());
   return tab->GetTopLevelDocAccessible();
 }
--- a/accessible/ipc/DocAccessibleParent.cpp
+++ b/accessible/ipc/DocAccessibleParent.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* 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 "DocAccessibleParent.h"
 #include "mozilla/a11y/Platform.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "xpcAccessibleDocument.h"
 #include "xpcAccEvents.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 
 #if defined(XP_WIN)
 #  include "AccessibleWrap.h"
 #  include "Compatibility.h"
@@ -536,17 +536,17 @@ ipc::IPCResult DocAccessibleParent::AddC
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult DocAccessibleParent::RecvShutdown() {
   Destroy();
 
-  auto mgr = static_cast<dom::TabParent*>(Manager());
+  auto mgr = static_cast<dom::BrowserParent*>(Manager());
   if (!mgr->IsDestroyed()) {
     if (!PDocAccessibleParent::Send__delete__(this)) {
       return IPC_FAIL_NO_REASON(mgr);
     }
   }
 
   return IPC_OK();
 }
@@ -649,17 +649,17 @@ xpcAccessibleGeneric* DocAccessibleParen
 }
 
 #if defined(XP_WIN)
 void DocAccessibleParent::MaybeInitWindowEmulation() {
   if (!nsWinUtils::IsWindowEmulationStarted()) {
     return;
   }
 
-  // XXX get the bounds from the tabParent instead of poking at accessibles
+  // XXX get the bounds from the browserParent instead of poking at accessibles
   // which might not exist yet.
   Accessible* outerDoc = OuterDocOfRemoteBrowser();
   if (!outerDoc) {
     return;
   }
 
   RootAccessible* rootDocument = outerDoc->RootAccessible();
   MOZ_ASSERT(rootDocument);
@@ -667,17 +667,17 @@ void DocAccessibleParent::MaybeInitWindo
   bool isActive = true;
   nsIntRect rect(CW_USEDEFAULT, CW_USEDEFAULT, 0, 0);
   if (Compatibility::IsDolphin()) {
     rect = Bounds();
     nsIntRect rootRect = rootDocument->Bounds();
     rect.MoveToX(rootRect.X() - rect.X());
     rect.MoveToY(rect.Y() - rootRect.Y());
 
-    auto tab = static_cast<dom::TabParent*>(Manager());
+    auto tab = static_cast<dom::BrowserParent*>(Manager());
     tab->GetDocShellIsActive(&isActive);
   }
 
   nsWinUtils::NativeWindowCreateProc onCreate([this](HWND aHwnd) -> void {
     IDispatchHolder hWndAccHolder;
 
     ::SetPropW(aHwnd, kPropNameDocAccParent, reinterpret_cast<HANDLE>(this));
 
@@ -703,17 +703,17 @@ void DocAccessibleParent::MaybeInitWindo
   MOZ_ASSERT(hWnd);
 }
 
 /**
  * @param aCOMProxy COM Proxy to the document in the content process.
  */
 void DocAccessibleParent::SendParentCOMProxy() {
   // Make sure that we're not racing with a tab shutdown
-  auto tab = static_cast<dom::TabParent*>(Manager());
+  auto tab = static_cast<dom::BrowserParent*>(Manager());
   MOZ_ASSERT(tab);
   if (tab->IsDestroyed()) {
     return;
   }
 
   Accessible* outerDoc = OuterDocOfRemoteBrowser();
   if (!outerDoc) {
     return;
--- a/accessible/ipc/ProxyAccessibleBase.cpp
+++ b/accessible/ipc/ProxyAccessibleBase.cpp
@@ -7,17 +7,17 @@
 #include "DocAccessible.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/a11y/DocManager.h"
 #include "mozilla/a11y/Platform.h"
 #include "mozilla/a11y/ProxyAccessibleBase.h"
 #include "mozilla/a11y/ProxyAccessible.h"
 #include "mozilla/a11y/Role.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/Unused.h"
 #include "RelationType.h"
 #include "xpcAccessibleDocument.h"
 
 namespace mozilla {
 namespace a11y {
 
 template <class Derived>
@@ -111,17 +111,17 @@ Derived* ProxyAccessibleBase<Derived>::E
     index++;
   }
 
   return nullptr;
 }
 
 template <class Derived>
 Accessible* ProxyAccessibleBase<Derived>::OuterDocOfRemoteBrowser() const {
-  auto tab = static_cast<dom::TabParent*>(mDoc->Manager());
+  auto tab = static_cast<dom::BrowserParent*>(mDoc->Manager());
   dom::Element* frame = tab->GetOwnerElement();
   NS_ASSERTION(frame, "why isn't the tab in a frame!");
   if (!frame) return nullptr;
 
   DocAccessible* chromeDoc = GetExistingDocAccessible(frame->OwnerDoc());
 
   return chromeDoc ? chromeDoc->GetAccessible(frame) : nullptr;
 }
--- a/accessible/ipc/other/ProxyAccessible.cpp
+++ b/accessible/ipc/other/ProxyAccessible.cpp
@@ -4,17 +4,17 @@
  * 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 "ProxyAccessible.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "DocAccessible.h"
 #include "mozilla/a11y/DocManager.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/Unused.h"
 #include "mozilla/a11y/Platform.h"
 #include "RelationType.h"
 #include "mozilla/a11y/Role.h"
 #include "xpcAccessibleDocument.h"
 
 namespace mozilla {
 namespace a11y {
--- a/accessible/ipc/win/DocAccessibleChild.cpp
+++ b/accessible/ipc/win/DocAccessibleChild.cpp
@@ -72,34 +72,34 @@ ipc::IPCResult DocAccessibleChild::RecvE
   return IPC_OK();
 }
 
 HWND DocAccessibleChild::GetNativeWindowHandle() const {
   if (mEmulatedWindowHandle) {
     return mEmulatedWindowHandle;
   }
 
-  auto tab = static_cast<dom::TabChild*>(Manager());
+  auto tab = static_cast<dom::BrowserChild*>(Manager());
   MOZ_ASSERT(tab);
   return reinterpret_cast<HWND>(tab->GetNativeWindowHandle());
 }
 
 void DocAccessibleChild::PushDeferredEvent(UniquePtr<DeferredEvent> aEvent) {
   DocAccessibleChild* topLevelIPCDoc = nullptr;
 
   if (mDoc && mDoc->IsRoot()) {
     topLevelIPCDoc = this;
   } else {
-    auto tabChild = static_cast<dom::TabChild*>(Manager());
-    if (!tabChild) {
+    auto browserChild = static_cast<dom::BrowserChild*>(Manager());
+    if (!browserChild) {
       return;
     }
 
     topLevelIPCDoc = static_cast<DocAccessibleChild*>(
-        tabChild->GetTopLevelDocAccessibleChild());
+        browserChild->GetTopLevelDocAccessibleChild());
   }
 
   if (topLevelIPCDoc) {
     topLevelIPCDoc->mDeferredEvents.AppendElement(std::move(aEvent));
   }
 }
 
 bool DocAccessibleChild::SendEvent(const uint64_t& aID, const uint32_t& aType) {
@@ -250,19 +250,19 @@ bool DocAccessibleChild::SendScrollingEv
       this, aID, aType, aScrollX, aScrollY, aMaxScrollX, aMaxScrollY));
   return true;
 }
 
 bool DocAccessibleChild::ConstructChildDocInParentProcess(
     DocAccessibleChild* aNewChildDoc, uint64_t aUniqueID, uint32_t aMsaaID) {
   if (IsConstructedInParentProcess()) {
     // We may send the constructor immediately
-    auto tabChild = static_cast<dom::TabChild*>(Manager());
-    MOZ_ASSERT(tabChild);
-    bool result = tabChild->SendPDocAccessibleConstructor(
+    auto browserChild = static_cast<dom::BrowserChild*>(Manager());
+    MOZ_ASSERT(browserChild);
+    bool result = browserChild->SendPDocAccessibleConstructor(
         aNewChildDoc, this, aUniqueID, aMsaaID, IAccessibleHolder());
     if (result) {
       aNewChildDoc->SetConstructedInParentProcess();
     }
     return result;
   }
 
   PushDeferredEvent(MakeUnique<SerializedChildDocConstructor>(
--- a/accessible/ipc/win/DocAccessibleChild.h
+++ b/accessible/ipc/win/DocAccessibleChild.h
@@ -4,17 +4,17 @@
  * 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/. */
 
 #ifndef mozilla_a11y_DocAccessibleChild_h
 #define mozilla_a11y_DocAccessibleChild_h
 
 #include "mozilla/a11y/COMPtrTypes.h"
 #include "mozilla/a11y/DocAccessibleChildBase.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/mscom/Ptr.h"
 
 namespace mozilla {
 namespace a11y {
 
 /*
  * These objects handle content side communication for an accessible document,
  * and their lifetime is the same as the document they represent.
@@ -284,19 +284,20 @@ class DocAccessibleChild : public DocAcc
                                   DocAccessibleChild* aParentIPCDoc,
                                   uint64_t aUniqueID, uint32_t aMsaaID)
         : DeferredEvent(aParentIPCDoc),
           mIPCDoc(aIPCDoc),
           mUniqueID(aUniqueID),
           mMsaaID(aMsaaID) {}
 
     void Dispatch(DocAccessibleChild* aParentIPCDoc) override {
-      auto tabChild = static_cast<dom::TabChild*>(aParentIPCDoc->Manager());
-      MOZ_ASSERT(tabChild);
-      Unused << tabChild->SendPDocAccessibleConstructor(
+      auto browserChild =
+          static_cast<dom::BrowserChild*>(aParentIPCDoc->Manager());
+      MOZ_ASSERT(browserChild);
+      Unused << browserChild->SendPDocAccessibleConstructor(
           mIPCDoc, aParentIPCDoc, mUniqueID, mMsaaID, IAccessibleHolder());
       mIPCDoc->SetConstructedInParentProcess();
     }
 
     DocAccessibleChild* mIPCDoc;
     uint64_t mUniqueID;
     uint32_t mMsaaID;
   };
--- a/accessible/ipc/win/ProxyAccessible.cpp
+++ b/accessible/ipc/win/ProxyAccessible.cpp
@@ -8,17 +8,17 @@
 #include "ProxyAccessible.h"
 #include "ia2AccessibleRelation.h"
 #include "ia2AccessibleValue.h"
 #include "IGeckoCustom.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "DocAccessible.h"
 #include "mozilla/a11y/DocManager.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/Unused.h"
 #include "mozilla/a11y/Platform.h"
 #include "RelationType.h"
 #include "mozilla/a11y/Role.h"
 #include "xpcAccessibleDocument.h"
 
 #include <comutil.h>
 
--- a/accessible/windows/msaa/AccessibleWrap.cpp
+++ b/accessible/windows/msaa/AccessibleWrap.cpp
@@ -30,17 +30,17 @@
 #  include "Logging.h"
 #endif
 
 #include "nsIMutableArray.h"
 #include "nsIFrame.h"
 #include "nsIScrollableFrame.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/dom/NodeInfo.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "nsIServiceManager.h"
 #include "nsNameSpaceManager.h"
 #include "nsTextFormatter.h"
 #include "nsView.h"
 #include "nsViewManager.h"
 #include "nsEventMap.h"
 #include "nsArrayUtils.h"
 #include "mozilla/Preferences.h"
@@ -1305,17 +1305,17 @@ static already_AddRefed<IDispatch> GetPr
   auto wrapper = static_cast<DocProxyAccessibleWrap*>(WrapperFor(aDoc));
   RefPtr<IAccessible> comProxy;
   int32_t docWrapperChildId = AccessibleWrap::GetChildIDFor(wrapper);
   // Only top level document accessible proxies are created with a pointer to
   // their COM proxy.
   if (aDoc->IsTopLevel()) {
     wrapper->GetNativeInterface(getter_AddRefs(comProxy));
   } else {
-    auto tab = static_cast<dom::TabParent*>(aDoc->Manager());
+    auto tab = static_cast<dom::BrowserParent*>(aDoc->Manager());
     MOZ_ASSERT(tab);
     DocAccessibleParent* topLevelDoc = tab->GetTopLevelDocAccessible();
     MOZ_ASSERT(topLevelDoc && topLevelDoc->IsTopLevel());
     VARIANT docId = {{{VT_I4}}};
     docId.lVal = docWrapperChildId;
     RefPtr<IDispatch> disp = GetProxiedAccessibleInSubtree(topLevelDoc, docId);
     if (!disp) {
       return nullptr;
--- a/accessible/windows/msaa/DocAccessibleWrap.cpp
+++ b/accessible/windows/msaa/DocAccessibleWrap.cpp
@@ -3,17 +3,17 @@
 /* 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 "DocAccessibleWrap.h"
 
 #include "Compatibility.h"
 #include "mozilla/PresShell.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "DocAccessibleChild.h"
 #include "nsWinUtils.h"
 #include "Role.h"
 #include "RootAccessible.h"
 #include "sdnDocAccessible.h"
 #include "Statistics.h"
 
 #include "nsIDocShell.h"
--- a/browser/actors/BrowserTabChild.jsm
+++ b/browser/actors/BrowserTabChild.jsm
@@ -58,20 +58,20 @@ class BrowserTabChild extends ActorChild
       case "Browser:AppTab":
         if (this.docShell) {
           this.docShell.isAppTab = message.data.isAppTab;
         }
         break;
 
       case "Browser:HasSiblings":
         try {
-          let tabChild = this.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
-                             .getInterface(Ci.nsITabChild);
+          let browserChild = this.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                             .getInterface(Ci.nsIBrowserChild);
           let hasSiblings = message.data;
-          tabChild.hasSiblings = hasSiblings;
+          browserChild.hasSiblings = hasSiblings;
         } catch (e) {
         }
         break;
 
       // XXX(nika): Should we try to call this in the parent process instead?
       case "Browser:Reload":
         /* First, we'll try to use the session history object to reload so
          * that framesets are handled properly. If we're in a special
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -5641,17 +5641,17 @@ function nsBrowserAccess() { }
 
 nsBrowserAccess.prototype = {
   QueryInterface: ChromeUtils.generateQI([Ci.nsIBrowserDOMWindow]),
 
   _openURIInNewTab(aURI, aReferrerInfo, aIsPrivate,
                    aIsExternal, aForceNotRemote = false,
                    aUserContextId = Ci.nsIScriptSecurityManager.DEFAULT_USER_CONTEXT_ID,
                    aOpenerWindow = null, aOpenerBrowser = null,
-                   aTriggeringPrincipal = null, aNextTabParentId = 0, aName = "", aCsp = null) {
+                   aTriggeringPrincipal = null, aNextRemoteTabId = 0, aName = "", aCsp = null) {
     let win, needToFocusWin;
 
     // try the current window.  if we're in a popup, fall back on the most recent browser window
     if (window.toolbar.visible) {
       win = window;
     } else {
       win = BrowserWindowTracker.getTopWindow({private: aIsPrivate});
       needToFocusWin = true;
@@ -5674,17 +5674,17 @@ nsBrowserAccess.prototype = {
                                       triggeringPrincipal: aTriggeringPrincipal,
                                       referrerInfo: aReferrerInfo,
                                       userContextId: aUserContextId,
                                       fromExternal: aIsExternal,
                                       inBackground: loadInBackground,
                                       forceNotRemote: aForceNotRemote,
                                       opener: aOpenerWindow,
                                       openerBrowser: aOpenerBrowser,
-                                      nextTabParentId: aNextTabParentId,
+                                      nextRemoteTabId: aNextRemoteTabId,
                                       name: aName,
                                       csp: aCsp,
                                       });
     let browser = win.gBrowser.getBrowserForTab(tab);
 
     if (needToFocusWin || (!loadInBackground && aIsExternal))
       win.focus();
 
@@ -5813,32 +5813,32 @@ nsBrowserAccess.prototype = {
         }
         if (!Services.prefs.getBoolPref("browser.tabs.loadDivertedInBackground"))
           window.focus();
     }
     return newWindow;
   },
 
   createContentWindowInFrame: function browser_createContentWindowInFrame(
-                              aURI, aParams, aWhere, aFlags, aNextTabParentId,
+                              aURI, aParams, aWhere, aFlags, aNextRemoteTabId,
                               aName) {
     // Passing a null-URI to only create the content window.
     return this.getContentWindowOrOpenURIInFrame(null, aParams, aWhere, aFlags,
-                                                 aNextTabParentId, aName);
+                                                 aNextRemoteTabId, aName);
   },
 
   openURIInFrame: function browser_openURIInFrame(aURI, aParams, aWhere, aFlags,
-                                                  aNextTabParentId, aName) {
+                                                  aNextRemoteTabId, aName) {
     return this.getContentWindowOrOpenURIInFrame(aURI, aParams, aWhere, aFlags,
-                                                 aNextTabParentId, aName);
+                                                 aNextRemoteTabId, aName);
   },
 
   getContentWindowOrOpenURIInFrame: function browser_getContentWindowOrOpenURIInFrame(
                                     aURI, aParams, aWhere, aFlags,
-                                    aNextTabParentId, aName) {
+                                    aNextRemoteTabId, aName) {
     if (aWhere != Ci.nsIBrowserDOMWindow.OPEN_NEWTAB) {
       dump("Error: openURIInFrame can only open in new tabs");
       return null;
     }
 
     var isExternal = !!(aFlags & Ci.nsIBrowserDOMWindow.OPEN_EXTERNAL);
 
     var userContextId = aParams.openerOriginAttributes &&
@@ -5847,17 +5847,17 @@ nsBrowserAccess.prototype = {
                           : Ci.nsIScriptSecurityManager.DEFAULT_USER_CONTEXT_ID;
 
     return this._openURIInNewTab(aURI,
                                  aParams.referrerInfo,
                                  aParams.isPrivate,
                                  isExternal, false,
                                  userContextId, null, aParams.openerBrowser,
                                  aParams.triggeringPrincipal,
-                                 aNextTabParentId, aName, aParams.csp);
+                                 aNextRemoteTabId, aName, aParams.csp);
   },
 
   isTabContentWindow(aWindow) {
     return gBrowser.browsers.some(browser => browser.contentWindow == aWindow);
   },
 
   canClose() {
     return CanCloseWindow();
--- a/browser/base/content/content.js
+++ b/browser/base/content/content.js
@@ -6,17 +6,17 @@
 /* This content script should work in any browser or iframe and should not
  * depend on the frame being contained in tabbrowser. */
 
 /* eslint-env mozilla/frame-script */
 /* eslint no-unused-vars: ["error", {args: "none"}] */
 
 var {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 
-// TabChildGlobal
+// BrowserChildGlobal
 var global = this;
 
 XPCOMUtils.defineLazyModuleGetters(this, {
   ContentMetaHandler: "resource:///modules/ContentMetaHandler.jsm",
   LoginFormFactory: "resource://gre/modules/LoginFormFactory.jsm",
   InsecurePasswordUtils: "resource://gre/modules/InsecurePasswordUtils.jsm",
   ContextMenuChild: "resource:///actors/ContextMenuChild.jsm",
 });
--- a/browser/base/content/tab-content.js
+++ b/browser/base/content/tab-content.js
@@ -13,17 +13,17 @@ ChromeUtils.defineModuleGetter(this, "E1
   "resource://gre/modules/E10SUtils.jsm");
 ChromeUtils.defineModuleGetter(this, "BrowserUtils",
   "resource://gre/modules/BrowserUtils.jsm");
 
 var {ActorManagerChild} = ChromeUtils.import("resource://gre/modules/ActorManagerChild.jsm");
 
 ActorManagerChild.attach(this, "browsers");
 
-// TabChildGlobal
+// BrowserChildGlobal
 var global = this;
 
 // Keep a reference to the translation content handler to avoid it it being GC'ed.
 var trHandler = null;
 if (Services.prefs.getBoolPref("browser.translation.detectLanguage")) {
   var {TranslationContentHandler} = ChromeUtils.import("resource:///modules/translation/TranslationContentHandler.jsm");
   trHandler = new TranslationContentHandler(global, docShell);
 }
@@ -51,17 +51,17 @@ var WebBrowserChrome = {
   reloadInFreshProcess(aDocShell, aURI, aReferrer, aTriggeringPrincipal, aLoadFlags, aCsp) {
     E10SUtils.redirectLoad(aDocShell, aURI, aReferrer, aTriggeringPrincipal, true, aLoadFlags, aCsp);
     return true;
   },
 };
 
 if (Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT) {
   let tabchild = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
-                         .getInterface(Ci.nsITabChild);
+                         .getInterface(Ci.nsIBrowserChild);
   tabchild.webBrowserChrome = WebBrowserChrome;
 }
 
 Services.obs.notifyObservers(this, "tab-content-frameloader-created");
 
 // Remove this once bug 1397365 is fixed.
 addEventListener("MozAfterPaint", function onFirstNonBlankPaint() {
   if (content.document.documentURI == "about:blank" && !content.opener)
--- a/browser/base/content/tabbrowser.js
+++ b/browser/base/content/tabbrowser.js
@@ -1398,17 +1398,17 @@ window._gBrowser = {
     var aForceNotRemote;
     var aPreferredRemoteType;
     var aUserContextId;
     var aSameProcessAsFrameLoader;
     var aOriginPrincipal;
     var aOpener;
     var aOpenerBrowser;
     var aCreateLazyBrowser;
-    var aNextTabParentId;
+    var aNextRemoteTabId;
     var aFocusUrlBar;
     var aName;
     var aCsp;
     if (arguments.length == 2 &&
         typeof arguments[1] == "object" &&
         !(arguments[1] instanceof Ci.nsIURI)) {
       let params = arguments[1];
       aTriggeringPrincipal = params.triggeringPrincipal;
@@ -1425,17 +1425,17 @@ window._gBrowser = {
       aForceNotRemote = params.forceNotRemote;
       aPreferredRemoteType = params.preferredRemoteType;
       aUserContextId = params.userContextId;
       aSameProcessAsFrameLoader = params.sameProcessAsFrameLoader;
       aOriginPrincipal = params.originPrincipal;
       aOpener = params.opener;
       aOpenerBrowser = params.openerBrowser;
       aCreateLazyBrowser = params.createLazyBrowser;
-      aNextTabParentId = params.nextTabParentId;
+      aNextRemoteTabId = params.nextRemoteTabId;
       aFocusUrlBar = params.focusUrlBar;
       aName = params.name;
       aCsp = params.csp;
     }
 
     // all callers of loadOneTab need to pass a valid triggeringPrincipal.
     if (!aTriggeringPrincipal) {
       throw new Error("Required argument triggeringPrincipal missing within loadOneTab");
@@ -1460,17 +1460,17 @@ window._gBrowser = {
       forceNotRemote: aForceNotRemote,
       createLazyBrowser: aCreateLazyBrowser,
       preferredRemoteType: aPreferredRemoteType,
       userContextId: aUserContextId,
       originPrincipal: aOriginPrincipal,
       sameProcessAsFrameLoader: aSameProcessAsFrameLoader,
       opener: aOpener,
       openerBrowser: aOpenerBrowser,
-      nextTabParentId: aNextTabParentId,
+      nextRemoteTabId: aNextRemoteTabId,
       focusUrlBar: aFocusUrlBar,
       name: aName,
       csp: aCsp,
     });
     if (!bgLoad)
       this.selectedTab = tab;
 
     return tab;
@@ -1819,17 +1819,17 @@ window._gBrowser = {
     }
 
     return false;
   },
 
   createBrowser({
     isPreloadBrowser,
     name,
-    nextTabParentId,
+    nextRemoteTabId,
     openerWindow,
     recordExecution,
     remoteType,
     replayExecution,
     sameProcessAsFrameLoader,
     uriIsAboutBlank,
     userContextId,
   } = {}) {
@@ -1898,22 +1898,22 @@ window._gBrowser = {
      *      therefore the 'preloadedState' attribute is removed from
      *      that browser altogether
      * See more details on Bug 1420285.
      */
     if (isPreloadBrowser) {
       b.setAttribute("preloadedState", "preloaded");
     }
 
-    if (nextTabParentId) {
+    if (nextRemoteTabId) {
       if (!remoteType) {
-        throw new Error("Cannot have nextTabParentId without a remoteType");
+        throw new Error("Cannot have nextRemoteTabId without a remoteType");
       }
       // Gecko is going to read this attribute and use it.
-      b.setAttribute("nextTabParentId", nextTabParentId.toString());
+      b.setAttribute("nextRemoteTabId", nextRemoteTabId.toString());
     }
 
     if (sameProcessAsFrameLoader) {
       b.sameProcessAsFrameLoader = sameProcessAsFrameLoader;
     }
 
     // This will be used by gecko to control the name of the opened
     // window.
@@ -2252,17 +2252,17 @@ window._gBrowser = {
     createLazyBrowser,
     eventDetail,
     focusUrlBar,
     forceNotRemote,
     fromExternal,
     index,
     lazyTabTitle,
     name,
-    nextTabParentId,
+    nextRemoteTabId,
     noInitialLabel,
     opener,
     openerBrowser,
     originPrincipal,
     ownerTab,
     pinned,
     postData,
     preferredRemoteType,
@@ -2477,17 +2477,17 @@ window._gBrowser = {
       if (!b) {
         // No preloaded browser found, create one.
         b = this.createBrowser({
           remoteType,
           uriIsAboutBlank,
           userContextId,
           sameProcessAsFrameLoader,
           openerWindow: opener,
-          nextTabParentId,
+          nextRemoteTabId,
           name,
           recordExecution,
           replayExecution,
         });
       }
 
       t.linkedBrowser = b;
 
@@ -2855,18 +2855,18 @@ window._gBrowser = {
         tabbrowser._endRemoveTab(tab);
       }
     }, 3000, aTab, this);
   },
 
   _hasBeforeUnload(aTab) {
     let browser = aTab.linkedBrowser;
     return browser.isRemoteBrowser && browser.frameLoader &&
-           browser.frameLoader.tabParent &&
-           browser.frameLoader.tabParent.hasBeforeUnload;
+           browser.frameLoader.remoteTab &&
+           browser.frameLoader.remoteTab.hasBeforeUnload;
   },
 
   _beginRemoveTab(aTab, {
     adoptedByTab,
     closeWindowWithLastTab,
     closeWindowFastpath,
     skipPermitUnload,
   } = {}) {
@@ -4260,17 +4260,17 @@ window._gBrowser = {
                           .replace("#1", affectedTabsLength);
       }
     } else {
       label = tab._fullLabel || tab.getAttribute("label");
       if (AppConstants.NIGHTLY_BUILD) {
         if (tab.linkedBrowser &&
             tab.linkedBrowser.isRemoteBrowser &&
             tab.linkedBrowser.frameLoader) {
-          label += " (pid " + tab.linkedBrowser.frameLoader.tabParent.osPid + ")";
+          label += " (pid " + tab.linkedBrowser.frameLoader.remoteTab.osPid + ")";
 
           if (window.docShell.QueryInterface(Ci.nsILoadContext).useRemoteSubframes) {
             label += " [F]";
           }
         }
       }
       if (tab.userContextId) {
         label = gTabBrowserBundle.formatStringFromName("tabs.containers.tooltip", [label, ContextualIdentityService.getUserContextLabel(tab.userContextId)], 2);
--- a/browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
+++ b/browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
@@ -61,31 +61,31 @@ add_task(async function setup() {
  */
 add_task(async function activity_stream_in_privileged_content_process() {
   Services.ppmm.releaseCachedProcesses();
 
   await BrowserTestUtils.withNewTab(ABOUT_NEWTAB, async function(browser1) {
     checkBrowserRemoteType(browser1, E10SUtils.PRIVILEGED_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
-    let privilegedPid = browser1.frameLoader.tabParent.osPid;
+    let privilegedPid = browser1.frameLoader.remoteTab.osPid;
 
     for (let url of [
       ABOUT_NEWTAB,
       ABOUT_WELCOME,
       ABOUT_HOME,
       `${ABOUT_NEWTAB}#foo`,
       `${ABOUT_WELCOME}#bar`,
       `${ABOUT_HOME}#baz`,
       `${ABOUT_NEWTAB}?q=foo`,
       `${ABOUT_WELCOME}?q=bar`,
       `${ABOUT_HOME}?q=baz`,
     ]) {
       await BrowserTestUtils.withNewTab(url, async function(browser2) {
-        is(browser2.frameLoader.tabParent.osPid, privilegedPid,
+        is(browser2.frameLoader.remoteTab.osPid, privilegedPid,
           "Check that about:newtab tabs are in the same privileged content process.");
       });
     }
   });
 
   Services.ppmm.releaseCachedProcesses();
 });
 
@@ -137,76 +137,76 @@ add_task(async function process_switchin
  */
 add_task(async function process_switching_through_navigation_features() {
   Services.ppmm.releaseCachedProcesses();
 
   await BrowserTestUtils.withNewTab(ABOUT_NEWTAB, async function(browser) {
     checkBrowserRemoteType(browser, E10SUtils.PRIVILEGED_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
-    let privilegedPid = browser.frameLoader.tabParent.osPid;
+    let privilegedPid = browser.frameLoader.remoteTab.osPid;
 
     // Check that about:newtab opened from JS in about:newtab page is in the same process.
     let promiseTabOpened = BrowserTestUtils.waitForNewTab(gBrowser, ABOUT_NEWTAB, true);
     await ContentTask.spawn(browser, ABOUT_NEWTAB, uri => {
       content.open(uri, "_blank");
     });
     let newTab = await promiseTabOpened;
     registerCleanupFunction(async function() {
       BrowserTestUtils.removeTab(newTab);
     });
     browser = newTab.linkedBrowser;
-    is(browser.frameLoader.tabParent.osPid, privilegedPid,
+    is(browser.frameLoader.remoteTab.osPid, privilegedPid,
       "Check that new tab opened from about:newtab is loaded in privileged content process.");
 
     // Check that reload does not break the privileged content process affinity.
     BrowserReload();
     await BrowserTestUtils.browserLoaded(browser, false, ABOUT_NEWTAB);
-    is(browser.frameLoader.tabParent.osPid, privilegedPid,
+    is(browser.frameLoader.remoteTab.osPid, privilegedPid,
       "Check that about:newtab is still in privileged content process after reload.");
 
     // Load http webpage
     BrowserTestUtils.loadURI(browser, TEST_HTTP);
     await BrowserTestUtils.browserLoaded(browser, false, TEST_HTTP);
     checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
 
     // Check that using the history back feature switches back to privileged content process.
     let promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, ABOUT_NEWTAB);
     browser.goBack();
     await promiseLocation;
     // We will need to ensure that the process flip has fully completed so that
     // the navigation history data will be available when we do browser.goForward();
     await BrowserTestUtils.waitForEvent(newTab, "SSTabRestored");
-    is(browser.frameLoader.tabParent.osPid, privilegedPid,
+    is(browser.frameLoader.remoteTab.osPid, privilegedPid,
       "Check that about:newtab is still in privileged content process after history goBack.");
 
     // Check that using the history forward feature switches back to the web content process.
     promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, TEST_HTTP);
     browser.goForward();
     await promiseLocation;
     // We will need to ensure that the process flip has fully completed so that
     // the navigation history data will be available when we do browser.gotoIndex(0);
     await BrowserTestUtils.waitForEvent(newTab, "SSTabRestored");
     checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE,
       "Check that tab runs in the web content process after using history goForward.");
 
     // Check that goto history index does not break the affinity.
     promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, ABOUT_NEWTAB);
     browser.gotoIndex(0);
     await promiseLocation;
-    is(browser.frameLoader.tabParent.osPid, privilegedPid,
+    is(browser.frameLoader.remoteTab.osPid, privilegedPid,
       "Check that about:newtab is in privileged content process after history gotoIndex.");
 
     BrowserTestUtils.loadURI(browser, TEST_HTTP);
     await BrowserTestUtils.browserLoaded(browser, false, TEST_HTTP);
     checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
 
     // Check that location change causes a change in process type as well.
     await ContentTask.spawn(browser, ABOUT_NEWTAB, uri => {
       content.location = uri;
     });
     await BrowserTestUtils.browserLoaded(browser, false, ABOUT_NEWTAB);
-    is(browser.frameLoader.tabParent.osPid, privilegedPid,
+    is(browser.frameLoader.remoteTab.osPid, privilegedPid,
       "Check that about:newtab is in privileged content process after location change.");
   });
 
   Services.ppmm.releaseCachedProcesses();
 });
--- a/browser/base/content/test/tabs/browser_tabSpinnerProbe.js
+++ b/browser/base/content/test/tabs/browser_tabSpinnerProbe.js
@@ -56,17 +56,17 @@ async function testProbe(aProbe) {
   // bit of extra time to account for the tab spinner delay.
   delayTime += gBrowser.selectedTab.linkedBrowser.getTabBrowser()._getSwitcher().TAB_SWITCH_TIMEOUT;
 
   // In order for a spinner to be shown, the tab must have presented before.
   let origTab = gBrowser.selectedTab;
   let hangTab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
   let hangBrowser = hangTab.linkedBrowser;
   ok(hangBrowser.isRemoteBrowser, "New tab should be remote.");
-  ok(hangBrowser.frameLoader.tabParent.hasPresented, "New tab has presented.");
+  ok(hangBrowser.frameLoader.remoteTab.hasPresented, "New tab has presented.");
 
   // Now switch back to the original tab and set up our hang.
   await BrowserTestUtils.switchTab(gBrowser, origTab);
 
   let tabHangPromise = hangContentProcess(hangBrowser, delayTime);
   histogram.clear();
   let hangTabSwitch = BrowserTestUtils.switchTab(gBrowser, hangTab);
   await tabHangPromise;
--- a/browser/components/sessionstore/SessionStore.jsm
+++ b/browser/components/sessionstore/SessionStore.jsm
@@ -2292,24 +2292,24 @@ var SessionStoreInternal = {
       redirectLoadSwitchId: aSwitchId,
     };
 
     await SessionStore.navigateAndRestore(tab, loadArguments, -1);
 
     // If the process switch seems to have failed, send an error over to our
     // caller, to give it a chance to kill our channel.
     if (aBrowser.remoteType != aRemoteType ||
-        !aBrowser.frameLoader || !aBrowser.frameLoader.tabParent) {
+        !aBrowser.frameLoader || !aBrowser.frameLoader.remoteTab) {
       throw Cr.NS_ERROR_FAILURE;
     }
 
     // Tell our caller to redirect the load into this newly created process.
-    let tabParent = aBrowser.frameLoader.tabParent;
-    debug(`[process-switch]: new tabID: ${tabParent.tabId}`);
-    return tabParent;
+    let remoteTab = aBrowser.frameLoader.remoteTab;
+    debug(`[process-switch]: new tabID: ${remoteTab.tabId}`);
+    return remoteTab;
   },
 
   /**
    * Perform a destructive process switch into a distinct process.
    * This method is asynchronous, as it requires multiple calls into content
    * processes.
    */
   async _doProcessSwitch(aBrowsingContext, aRemoteType, aChannel, aSwitchId) {
@@ -5246,21 +5246,21 @@ var SessionStoreInternal = {
   _sendRestoreHistory(browser, options) {
     // If the tabData which we're sending down has any sessionStorage associated
     // with it, we need to send down permissions for the domains, as this
     // information will be needed to correctly restore the session.
     if (options.tabData.storage) {
       for (let origin of Object.getOwnPropertyNames(options.tabData.storage)) {
         try {
           let {frameLoader} = browser;
-          if (frameLoader.tabParent) {
+          if (frameLoader.remoteTab) {
             let attrs = browser.contentPrincipal.originAttributes;
             let dataPrincipal = Services.scriptSecurityManager.createCodebasePrincipalFromOrigin(origin);
             let principal = Services.scriptSecurityManager.createCodebasePrincipal(dataPrincipal.URI, attrs);
-            frameLoader.tabParent.transmitPermissionsForPrincipal(principal);
+            frameLoader.remoteTab.transmitPermissionsForPrincipal(principal);
           }
         } catch (e) {
           console.error(e);
         }
       }
     }
 
     browser.messageManager.sendAsyncMessage("SessionStore:restoreHistory", options);
--- a/browser/modules/AsyncTabSwitcher.jsm
+++ b/browser/modules/AsyncTabSwitcher.jsm
@@ -144,17 +144,17 @@ class AsyncTabSwitcher {
     this.window.addEventListener("occlusionstatechange", this);
     this.window.addEventListener("SwapDocShells", this, true);
     this.window.addEventListener("EndSwapDocShells", this, true);
 
     let initialTab = this.requestedTab;
     let initialBrowser = initialTab.linkedBrowser;
 
     let tabIsLoaded = !initialBrowser.isRemoteBrowser ||
-      initialBrowser.frameLoader.tabParent.hasLayers;
+      initialBrowser.frameLoader.remoteTab.hasLayers;
 
     // If we minimized the window before the switcher was activated,
     // we might have set  the preserveLayers flag for the current
     // browser. Let's clear it.
     initialBrowser.preserveLayers(false);
 
     if (!this.minimizedOrFullyOccluded) {
       this.log("Initial tab is loaded?: " + tabIsLoaded);
@@ -247,37 +247,37 @@ class AsyncTabSwitcher {
   setTabState(tab, state) {
     if (state == this.getTabState(tab)) {
       return;
     }
 
     this.setTabStateNoAction(tab, state);
 
     let browser = tab.linkedBrowser;
-    let { tabParent } = browser.frameLoader;
+    let { remoteTab } = browser.frameLoader;
     if (state == this.STATE_LOADING) {
       this.assert(!this.minimizedOrFullyOccluded);
 
       // If we're not in the process of warming this tab, we
       // don't need to delay activating its DocShell.
       if (!this.warmingTabs.has(tab)) {
         browser.docShellIsActive = true;
       }
 
-      if (tabParent) {
+      if (remoteTab) {
         browser.renderLayers = true;
       } else {
         this.onLayersReady(browser);
       }
     } else if (state == this.STATE_UNLOADING) {
       this.unwarmTab(tab);
       // Setting the docShell to be inactive will also cause it
       // to stop rendering layers.
       browser.docShellIsActive = false;
-      if (!tabParent) {
+      if (!remoteTab) {
         this.onLayersCleared(browser);
       }
     } else if (state == this.STATE_LOADED) {
       this.maybeActivateDocShell(tab);
     }
 
     if (!tab.linkedBrowser.isRemoteBrowser) {
       // setTabState is potentially re-entrant in the non-remote case,
@@ -331,38 +331,38 @@ class AsyncTabSwitcher {
   updateDisplay() {
     let requestedTabState = this.getTabState(this.requestedTab);
     let requestedBrowser = this.requestedTab.linkedBrowser;
 
     // It is often more desirable to show a blank tab when appropriate than
     // the tab switch spinner - especially since the spinner is usually
     // preceded by a perceived lag of TAB_SWITCH_TIMEOUT ms in the
     // tab switch. We can hide this lag, and hide the time being spent
-    // constructing TabChild's, layer trees, etc, by showing a blank
+    // constructing BrowserChild's, layer trees, etc, by showing a blank
     // tab instead and focusing it immediately.
     let shouldBeBlank = false;
     if (requestedBrowser.isRemoteBrowser) {
       // If a tab is remote and the window is not minimized, we can show a
       // blank tab instead of a spinner in the following cases:
       //
       // 1. The tab has just crashed, and we haven't started showing the
-      //    tab crashed page yet (in this case, the TabParent is null)
+      //    tab crashed page yet (in this case, the RemoteTab is null)
       // 2. The tab has never presented, and has not finished loading
       //    a non-local-about: page.
       //
       // For (2), "finished loading a non-local-about: page" is
       // determined by the busy state on the tab element and checking
       // if the loaded URI is local.
       let hasSufficientlyLoaded = !this.requestedTab.hasAttribute("busy") &&
         !this.tabbrowser.isLocalAboutURI(requestedBrowser.currentURI);
 
       let fl = requestedBrowser.frameLoader;
       shouldBeBlank = !this.minimizedOrFullyOccluded &&
-        (!fl.tabParent ||
-          (!hasSufficientlyLoaded && !fl.tabParent.hasPresented));
+        (!fl.remoteTab ||
+          (!hasSufficientlyLoaded && !fl.remoteTab.hasPresented));
     }
 
     this.log("Tab should be blank: " + shouldBeBlank);
     this.log("Requested tab is remote?: " + requestedBrowser.isRemoteBrowser);
 
     // Figure out which tab we actually want visible right now.
     let showTab = null;
     if (requestedTabState != this.STATE_LOADED &&
@@ -492,17 +492,17 @@ class AsyncTabSwitcher {
 
   maybeActivateDocShell(tab) {
     // If we've reached the point where the requested tab has entered
     // the loaded state, but the DocShell is still not yet active, we
     // should activate it.
     let browser = tab.linkedBrowser;
     let state = this.getTabState(tab);
     let canCheckDocShellState = !browser.mDestroyed &&
-      (browser.docShell || browser.frameLoader.tabParent);
+      (browser.docShell || browser.frameLoader.remoteTab);
     if (tab == this.requestedTab &&
         canCheckDocShellState &&
         state == this.STATE_LOADED &&
         !browser.docShellIsActive &&
         !this.minimizedOrFullyOccluded) {
       browser.docShellIsActive = true;
       this.logState("Set requested tab docshell to active and preserveLayers to false");
       // If we minimized the window before the switcher was activated,
@@ -888,17 +888,17 @@ class AsyncTabSwitcher {
 
     // If the tab is not yet inserted, closing, not remote,
     // crashed, already visible, or already requested, warming
     // up the tab makes no sense.
     if (this.minimizedOrFullyOccluded ||
         !tab.linkedPanel ||
         tab.closing ||
         !tab.linkedBrowser.isRemoteBrowser ||
-        !tab.linkedBrowser.frameLoader.tabParent) {
+        !tab.linkedBrowser.frameLoader.remoteTab) {
       return false;
     }
 
     return true;
   }
 
   shouldWarmTab(tab) {
     if (this.canWarmTab(tab)) {
--- a/devtools/client/framework/test/browser_two_tabs.js
+++ b/devtools/client/framework/test/browser_two_tabs.js
@@ -41,18 +41,18 @@ add_task(async () => {
 
 async function checkGetTab(client, tab1, tab2, targetFront1, targetFront2) {
   let front = await client.mainRoot.getTab({tab: tab1});
   is(targetFront1, front,
      "getTab returns the same target form for first tab");
   const filter = {};
   // Filter either by tabId or outerWindowID,
   // if we are running tests OOP or not.
-  if (tab1.linkedBrowser.frameLoader.tabParent) {
-    filter.tabId = tab1.linkedBrowser.frameLoader.tabParent.tabId;
+  if (tab1.linkedBrowser.frameLoader.remoteTab) {
+    filter.tabId = tab1.linkedBrowser.frameLoader.remoteTab.tabId;
   } else {
     const windowUtils = tab1.linkedBrowser.contentWindow.windowUtils;
     filter.outerWindowID = windowUtils.outerWindowID;
   }
   front = await client.mainRoot.getTab(filter);
   is(targetFront1, front,
      "getTab returns the same target form when filtering by tabId/outerWindowID");
   front = await client.mainRoot.getTab({tab: tab2});
--- a/devtools/client/responsive.html/browser/swap.js
+++ b/devtools/client/responsive.html/browser/swap.js
@@ -81,19 +81,19 @@ function swapToInnerBrowser({ tab, conta
   // silenced in the browser, because they are apparently expected in certain cases.
   // So, here we do our own check to verify that the swap actually did in fact take place,
   // making it much easier to track such errors when they happen.
   const swapBrowserDocShells = (ourTab, otherBrowser) => {
     // The verification step here assumes both browsers are remote.
     if (!ourTab.linkedBrowser.isRemoteBrowser || !otherBrowser.isRemoteBrowser) {
       throw new Error("Both browsers should be remote before swapping.");
     }
-    const contentTabId = ourTab.linkedBrowser.frameLoader.tabParent.tabId;
+    const contentTabId = ourTab.linkedBrowser.frameLoader.remoteTab.tabId;
     gBrowser._swapBrowserDocShells(ourTab, otherBrowser);
-    if (otherBrowser.frameLoader.tabParent.tabId != contentTabId) {
+    if (otherBrowser.frameLoader.remoteTab.tabId != contentTabId) {
       // Bug 1408602: Try to unwind to save tab content from being lost.
       throw new Error("Swapping tab content between browsers failed.");
     }
   };
 
   // Wait for a browser to load into a new frame loader.
   function loadURIWithNewFrameLoader(browser, uri, options) {
     return new Promise(resolve => {
--- a/devtools/client/webreplay/menu.js
+++ b/devtools/client/webreplay/menu.js
@@ -57,18 +57,18 @@ function ReloadAndStopRecordingTab() {
 
 function SaveRecording() {
   const { gBrowser } = Services.wm.getMostRecentWindow("navigator:browser");
   const fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
   const window = gBrowser.ownerGlobal;
   fp.init(window, null, Ci.nsIFilePicker.modeSave);
   fp.open(rv => {
     if (rv == Ci.nsIFilePicker.returnOK || rv == Ci.nsIFilePicker.returnReplace) {
-      const tabParent = gBrowser.selectedTab.linkedBrowser.frameLoader.tabParent;
-      if (!tabParent || !tabParent.saveRecording(fp.file.path)) {
+      const remoteTab = gBrowser.selectedTab.linkedBrowser.frameLoader.remoteTab;
+      if (!remoteTab || !remoteTab.saveRecording(fp.file.path)) {
         window.alert("Current tab is not recording");
       }
     }
   });
   Services.telemetry.scalarAdd("devtools.webreplay.save_recording", 1);
 }
 
 function ReplayNewTab() {
--- a/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-01.js
+++ b/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-01.js
@@ -10,19 +10,19 @@
 add_task(async function() {
   const recordingFile = newRecordingFile();
   const recordingTab = BrowserTestUtils.addTab(gBrowser, null,
                                                { recordExecution: "*" });
   gBrowser.selectedTab = recordingTab;
   openTrustedLinkIn(EXAMPLE_URL + "doc_rr_basic.html", "current");
   await once(Services.ppmm, "RecordingFinished");
 
-  const tabParent = recordingTab.linkedBrowser.frameLoader.tabParent;
-  ok(tabParent, "Found recording tab parent");
-  ok(tabParent.saveRecording(recordingFile), "Saved recording");
+  const remoteTab = recordingTab.linkedBrowser.frameLoader.remoteTab;
+  ok(remoteTab, "Found recording remote tab");
+  ok(remoteTab.saveRecording(recordingFile), "Saved recording");
   await once(Services.ppmm, "SaveRecordingFinished");
 
   const replayingTab = BrowserTestUtils.addTab(gBrowser, null,
                                                { replayExecution: recordingFile });
   gBrowser.selectedTab = replayingTab;
   await once(Services.ppmm, "HitRecordingEndpoint");
 
   const { target, toolbox } = await attachDebugger(replayingTab);
--- a/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-02.js
+++ b/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-02.js
@@ -21,19 +21,19 @@ add_task(async function() {
   let client = toolbox.threadClient;
   await client.interrupt();
   let bp = await setBreakpoint(client, "doc_rr_continuous.html", 14);
   await resumeToLine(client, 14);
   await resumeToLine(client, 14);
   await reverseStepOverToLine(client, 13);
   const lastNumberValue = await evaluateInTopFrame(target, "number");
 
-  const tabParent = recordingTab.linkedBrowser.frameLoader.tabParent;
-  ok(tabParent, "Found recording tab parent");
-  ok(tabParent.saveRecording(recordingFile), "Saved recording");
+  const remoteTab = recordingTab.linkedBrowser.frameLoader.remoteTab;
+  ok(remoteTab, "Found recording remote tab");
+  ok(remoteTab.saveRecording(recordingFile), "Saved recording");
   await once(Services.ppmm, "SaveRecordingFinished");
 
   await client.removeBreakpoint(bp);
   await toolbox.destroy();
   await gBrowser.removeTab(recordingTab);
 
   const replayingTab = BrowserTestUtils.addTab(gBrowser, null,
                                                { replayExecution: recordingFile });
--- a/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-03.js
+++ b/devtools/client/webreplay/mochitest/browser_dbg_rr_replay-03.js
@@ -12,19 +12,19 @@ add_task(async function() {
   await pushPref("devtools.recordreplay.enableRewinding", false);
 
   const recordingFile = newRecordingFile();
   const recordingTab = BrowserTestUtils.addTab(gBrowser, null, { recordExecution: "*" });
   gBrowser.selectedTab = recordingTab;
   openTrustedLinkIn(EXAMPLE_URL + "doc_rr_basic.html", "current");
   await once(Services.ppmm, "RecordingFinished");
 
-  const tabParent = recordingTab.linkedBrowser.frameLoader.tabParent;
-  ok(tabParent, "Found recording tab parent");
-  ok(tabParent.saveRecording(recordingFile), "Saved recording");
+  const remoteTab = recordingTab.linkedBrowser.frameLoader.remoteTab;
+  ok(remoteTab, "Found recording remote tab");
+  ok(remoteTab.saveRecording(recordingFile), "Saved recording");
   await once(Services.ppmm, "SaveRecordingFinished");
 
   const replayingTab = BrowserTestUtils.addTab(gBrowser, null,
                                                { replayExecution: recordingFile });
   gBrowser.selectedTab = replayingTab;
   await once(Services.ppmm, "HitRecordingEndpoint");
 
   ok(true, "Replayed to end of recording");
--- a/devtools/server/actors/targets/browsing-context.js
+++ b/devtools/server/actors/targets/browsing-context.js
@@ -695,17 +695,17 @@ const browsingContextTargetPrototype = {
     } else if (topic == "webnavigation-destroy") {
       this._onDocShellDestroy(subject);
     }
   },
 
   _onDocShellCreated(docShell) {
     // (chrome-)webnavigation-create is fired very early during docshell
     // construction. In new root docshells within child processes, involving
-    // TabChild, this event is from within this call:
+    // BrowserChild, this event is from within this call:
     //   https://hg.mozilla.org/mozilla-central/annotate/74d7fb43bb44/dom/ipc/TabChild.cpp#l912
     // whereas the chromeEventHandler (and most likely other stuff) is set
     // later:
     //   https://hg.mozilla.org/mozilla-central/annotate/74d7fb43bb44/dom/ipc/TabChild.cpp#l944
     // So wait a tick before watching it:
     DevToolsUtils.executeSoon(() => {
       // Bug 1142752: sometimes, the docshell appears to be immediately
       // destroyed, bailout early to prevent random exceptions.
--- a/devtools/server/actors/webbrowser.js
+++ b/devtools/server/actors/webbrowser.js
@@ -346,18 +346,18 @@ BrowserTabList.prototype.getTab = functi
     return Promise.reject({
       error: "noTab",
       message: "Unable to find tab with outerWindowID '" + outerWindowID + "'",
     });
   } else if (typeof tabId == "number") {
     // Tabs OOP
     for (const browser of this._getBrowsers()) {
       if (browser.frameLoader &&
-          browser.frameLoader.tabParent &&
-          browser.frameLoader.tabParent.tabId === tabId) {
+          browser.frameLoader.remoteTab &&
+          browser.frameLoader.remoteTab.tabId === tabId) {
         return this._getActorForBrowser(browser, browserActorOptions);
       }
     }
     return Promise.reject({
       error: "noTab",
       message: "Unable to find tab with tabId '" + tabId + "'",
     });
   }
--- a/devtools/shared/fronts/root.js
+++ b/devtools/shared/fronts/root.js
@@ -211,19 +211,19 @@ class RootFront extends FrontClassWithSp
     const packet = {};
     if (filter) {
       if (typeof (filter.outerWindowID) == "number") {
         packet.outerWindowID = filter.outerWindowID;
       } else if (typeof (filter.tabId) == "number") {
         packet.tabId = filter.tabId;
       } else if ("tab" in filter) {
         const browser = filter.tab.linkedBrowser;
-        if (browser.frameLoader.tabParent) {
+        if (browser.frameLoader.remoteTab) {
           // Tabs in child process
-          packet.tabId = browser.frameLoader.tabParent.tabId;
+          packet.tabId = browser.frameLoader.remoteTab.tabId;
         } else if (browser.outerWindowID) {
           // <xul:browser> tabs in parent process
           packet.outerWindowID = browser.outerWindowID;
         } else {
           // <iframe mozbrowser> tabs in parent process
           const windowUtils = browser.contentWindow.windowUtils;
           packet.outerWindowID = windowUtils.outerWindowID;
         }
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -52,17 +52,17 @@
 #include "mozilla/dom/PermissionMessageUtils.h"
 #include "mozilla/dom/PopupBlocker.h"
 #include "mozilla/dom/ProfileTimelineMarkerBinding.h"
 #include "mozilla/dom/ScreenOrientation.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/dom/ServiceWorkerInterceptController.h"
 #include "mozilla/dom/ServiceWorkerUtils.h"
 #include "mozilla/dom/SessionStorageManager.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/TabGroup.h"
 #include "mozilla/dom/ToJSValue.h"
 #include "mozilla/dom/ChildSHistory.h"
 #include "mozilla/dom/nsCSPContext.h"
 #include "mozilla/dom/LoadURIOptionsBinding.h"
 
 #include "mozilla/net/ReferrerPolicy.h"
 #include "mozilla/net/UrlClassifierFeatureFactory.h"
@@ -127,17 +127,17 @@
 #include "nsISelectionDisplay.h"
 #include "nsISHEntry.h"
 #include "nsISHistory.h"
 #include "nsISiteSecurityService.h"
 #include "nsISocketProvider.h"
 #include "nsIStringBundle.h"
 #include "nsIStructuredCloneContainer.h"
 #include "nsISupportsPrimitives.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 #include "nsITextToSubURI.h"
 #include "nsITimedChannel.h"
 #include "nsITimer.h"
 #include "nsITransportSecurityInfo.h"
 #include "nsIUploadChannel.h"
 #include "nsIURIFixup.h"
 #include "nsIURILoader.h"
 #include "nsIURIMutator.h"
@@ -651,18 +651,18 @@ nsDocShell::GetInterface(const nsIID& aI
       return presShell->QueryInterface(aIID, aSink);
     }
   } else if (aIID.Equals(NS_GET_IID(nsIDocShellTreeOwner))) {
     nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
     nsresult rv = GetTreeOwner(getter_AddRefs(treeOwner));
     if (NS_SUCCEEDED(rv) && treeOwner) {
       return treeOwner->QueryInterface(aIID, aSink);
     }
-  } else if (aIID.Equals(NS_GET_IID(nsITabChild))) {
-    *aSink = GetTabChild().take();
+  } else if (aIID.Equals(NS_GET_IID(nsIBrowserChild))) {
+    *aSink = GetBrowserChild().take();
     return *aSink ? NS_OK : NS_ERROR_FAILURE;
   } else {
     return nsDocLoader::GetInterface(aIID, aSink);
   }
 
   NS_IF_ADDREF(((nsISupports*)*aSink));
   return *aSink ? NS_OK : NS_NOINTERFACE;
 }
@@ -3187,28 +3187,31 @@ nsDocShell::SetTreeOwner(nsIDocShellTree
     NS_ENSURE_TRUE(child, NS_ERROR_FAILURE);
 
     if (child->ItemType() == mItemType) {
       child->SetTreeOwner(aTreeOwner);
     }
   }
 
   // If we're in the content process and have had a TreeOwner set on us, extract
-  // our TabChild actor. If we've already had our TabChild set, assert that it
-  // hasn't changed.
+  // our BrowserChild actor. If we've already had our BrowserChild set, assert
+  // that it hasn't changed.
   if (mTreeOwner && XRE_IsContentProcess()) {
-    nsCOMPtr<nsITabChild> newTabChild = do_GetInterface(mTreeOwner);
-    MOZ_ASSERT(newTabChild, "No TabChild actor for tree owner in Content!");
-
-    if (mTabChild) {
-      nsCOMPtr<nsITabChild> oldTabChild = do_QueryReferent(mTabChild);
-      MOZ_RELEASE_ASSERT(oldTabChild == newTabChild,
-                         "Cannot cahnge TabChild during nsDocShell lifetime!");
+    nsCOMPtr<nsIBrowserChild> newBrowserChild = do_GetInterface(mTreeOwner);
+    MOZ_ASSERT(newBrowserChild,
+               "No BrowserChild actor for tree owner in Content!");
+
+    if (mBrowserChild) {
+      nsCOMPtr<nsIBrowserChild> oldBrowserChild =
+          do_QueryReferent(mBrowserChild);
+      MOZ_RELEASE_ASSERT(
+          oldBrowserChild == newBrowserChild,
+          "Cannot cahnge BrowserChild during nsDocShell lifetime!");
     } else {
-      mTabChild = do_GetWeakReference(newTabChild);
+      mBrowserChild = do_GetWeakReference(newBrowserChild);
     }
   }
 
   // Our tree owner has changed. Recompute scriptability.
   //
   // Note that this is near-redundant with the recomputation in
   // SetDocLoaderParent(), but not so for the root DocShell, where the call to
   // SetTreeOwner() happens after the initial AddDocLoaderAsChildOfRoot(),
@@ -3675,18 +3678,18 @@ nsDocShell::GetDomWindow(mozIDOMWindowPr
   RefPtr<nsGlobalWindowOuter> window = mScriptGlobal;
   window.forget(aWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShell::GetMessageManager(ContentFrameMessageManager** aMessageManager) {
   RefPtr<ContentFrameMessageManager> mm;
-  if (RefPtr<TabChild> tabChild = TabChild::GetFrom(this)) {
-    mm = tabChild->GetMessageManager();
+  if (RefPtr<BrowserChild> browserChild = BrowserChild::GetFrom(this)) {
+    mm = browserChild->GetMessageManager();
   } else if (nsPIDOMWindowOuter* win = GetWindow()) {
     mm = win->GetMessageManager();
   }
   mm.forget(aMessageManager);
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -5016,17 +5019,17 @@ nsDocShell::Destroy() {
     mSessionHistory->EvictLocalContentViewers();
     mSessionHistory = nullptr;
   }
 
   mBrowsingContext->Detach();
 
   SetTreeOwner(nullptr);
 
-  mTabChild = nullptr;
+  mBrowserChild = nullptr;
 
   mChromeEventHandler = nullptr;
 
   mOnePermittedSandboxedNavigator = nullptr;
 
   // required to break ref cycle
   mSecurityUI = nullptr;
 
@@ -9741,18 +9744,18 @@ nsresult nsDocShell::DoURILoad(nsDocShel
   if (contentPolicyType == nsIContentPolicy::TYPE_DOCUMENT) {
     loadingNode = nullptr;
     loadingPrincipal = nullptr;
     loadingWindow = mScriptGlobal;
     if (XRE_IsContentProcess()) {
       // In e10s the child process doesn't have access to the element that
       // contains the browsing context (because that element is in the chrome
       // process).
-      nsCOMPtr<nsITabChild> tabChild = GetTabChild();
-      topLevelLoadingContext = ToSupports(tabChild);
+      nsCOMPtr<nsIBrowserChild> browserChild = GetBrowserChild();
+      topLevelLoadingContext = ToSupports(browserChild);
     } else {
       // This is for loading non-e10s tabs and toplevel windows of various
       // sorts.
       // For the toplevel window cases, requestingElement will be null.
       nsCOMPtr<Element> requestingElement =
           loadingWindow->GetFrameElementInternal();
       topLevelLoadingContext = requestingElement;
     }
@@ -13164,22 +13167,22 @@ void nsDocShell::UpdateGlobalHistoryTitl
     }
   }
 }
 
 bool nsDocShell::IsInvisible() { return mInvisible; }
 
 void nsDocShell::SetInvisible(bool aInvisible) { mInvisible = aInvisible; }
 
-void nsDocShell::SetOpener(nsITabParent* aOpener) {
+void nsDocShell::SetOpener(nsIRemoteTab* aOpener) {
   mOpener = do_GetWeakReference(aOpener);
 }
 
-nsITabParent* nsDocShell::GetOpener() {
-  nsCOMPtr<nsITabParent> opener(do_QueryReferent(mOpener));
+nsIRemoteTab* nsDocShell::GetOpener() {
+  nsCOMPtr<nsIRemoteTab> opener(do_QueryReferent(mOpener));
   return opener;
 }
 
 // The caller owns |aAsyncCause| here.
 void nsDocShell::NotifyJSRunToCompletionStart(const char* aReason,
                                               const char16_t* aFunctionName,
                                               const char16_t* aFilename,
                                               const uint32_t aLineNumber,
@@ -13286,23 +13289,23 @@ nsDocShell::GetEditingSession(nsIEditing
     return NS_ERROR_FAILURE;
   }
 
   *aEditSession = do_AddRef(mEditorData->GetEditingSession()).take();
   return *aEditSession ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-nsDocShell::GetScriptableTabChild(nsITabChild** aTabChild) {
-  *aTabChild = GetTabChild().take();
-  return *aTabChild ? NS_OK : NS_ERROR_FAILURE;
-}
-
-already_AddRefed<nsITabChild> nsDocShell::GetTabChild() {
-  nsCOMPtr<nsITabChild> tc = do_QueryReferent(mTabChild);
+nsDocShell::GetScriptableBrowserChild(nsIBrowserChild** aBrowserChild) {
+  *aBrowserChild = GetBrowserChild().take();
+  return *aBrowserChild ? NS_OK : NS_ERROR_FAILURE;
+}
+
+already_AddRefed<nsIBrowserChild> nsDocShell::GetBrowserChild() {
+  nsCOMPtr<nsIBrowserChild> tc = do_QueryReferent(mBrowserChild);
   return tc.forget();
 }
 
 nsCommandManager* nsDocShell::GetCommandManager() {
   NS_ENSURE_SUCCESS(EnsureCommandHandler(), nullptr);
   return mCommandManager;
 }
 
@@ -13333,22 +13336,23 @@ nsDocShell::GetIsOnlyToplevelInTabGroup(
 
   *aResult = true;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShell::GetAwaitingLargeAlloc(bool* aResult) {
   MOZ_ASSERT(aResult);
-  nsCOMPtr<nsITabChild> tabChild = GetTabChild();
-  if (!tabChild) {
+  nsCOMPtr<nsIBrowserChild> browserChild = GetBrowserChild();
+  if (!browserChild) {
     *aResult = false;
     return NS_OK;
   }
-  *aResult = static_cast<TabChild*>(tabChild.get())->IsAwaitingLargeAlloc();
+  *aResult =
+      static_cast<BrowserChild*>(browserChild.get())->IsAwaitingLargeAlloc();
   return NS_OK;
 }
 
 NS_IMETHODIMP_(void)
 nsDocShell::GetOriginAttributes(mozilla::OriginAttributes& aAttrs) {
   aAttrs = mOriginAttributes;
 }
 
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -29,17 +29,17 @@
 #include "nsIDOMStorageManager.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsILinkHandler.h"
 #include "nsILoadContext.h"
 #include "nsILoadURIDelegate.h"
 #include "nsINetworkInterceptController.h"
 #include "nsIRefreshURI.h"
 #include "nsIScrollable.h"
-#include "nsITabParent.h"
+#include "nsIRemoteTab.h"
 #include "nsIWebNavigation.h"
 #include "nsIWebPageDescriptor.h"
 #include "nsIWebProgressListener.h"
 
 #include "nsAutoPtr.h"
 #include "nsCharsetSource.h"
 #include "nsCOMPtr.h"
 #include "nsContentPolicyUtils.h"
@@ -961,18 +961,18 @@ class nsDocShell final : public nsDocLoa
   uint64_t mContentWindowID;
   nsCOMPtr<nsIContentViewer> mContentViewer;
   nsCOMPtr<nsIWidget> mParentWidget;
   RefPtr<mozilla::dom::ChildSHistory> mSessionHistory;
   nsCOMPtr<nsIWebBrowserFind> mFind;
   RefPtr<nsCommandManager> mCommandManager;
   RefPtr<mozilla::dom::BrowsingContext> mBrowsingContext;
 
-  // Weak reference to our TabChild actor.
-  nsWeakPtr mTabChild;
+  // Weak reference to our BrowserChild actor.
+  nsWeakPtr mBrowserChild;
 
   // Dimensions of the docshell
   nsIntRect mBounds;
 
   /**
    * Content-Type Hint of the most-recently initiated load. Used for
    * session history entries.
    */
--- a/docshell/base/nsDocShellTreeOwner.cpp
+++ b/docshell/base/nsDocShellTreeOwner.cpp
@@ -34,18 +34,18 @@
 #include "nsIImageLoadingContent.h"
 #include "nsIWebNavigation.h"
 #include "nsIStringBundle.h"
 #include "nsPIDOMWindow.h"
 #include "nsPIWindowRoot.h"
 #include "nsIWindowWatcher.h"
 #include "nsPIWindowWatcher.h"
 #include "nsIPrompt.h"
-#include "nsITabParent.h"
-#include "nsITabChild.h"
+#include "nsIRemoteTab.h"
+#include "nsIBrowserChild.h"
 #include "nsRect.h"
 #include "nsIWebBrowserChromeFocus.h"
 #include "nsIContent.h"
 #include "imgIContainer.h"
 #include "nsViewManager.h"
 #include "nsView.h"
 #include "nsIConstraintValidation.h"
 #include "mozilla/Attributes.h"
@@ -243,17 +243,17 @@ nsDocShellTreeOwner::ContentShellAdded(n
                                        bool aPrimary) {
   if (mTreeOwner) return mTreeOwner->ContentShellAdded(aContentShell, aPrimary);
 
   EnsureContentTreeOwner();
   aContentShell->SetTreeOwner(mContentTreeOwner);
 
   if (aPrimary) {
     mPrimaryContentShell = aContentShell;
-    mPrimaryTabParent = nullptr;
+    mPrimaryRemoteTab = nullptr;
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShellTreeOwner::ContentShellRemoved(nsIDocShellTreeItem* aContentShell) {
   if (mTreeOwner) {
     return mTreeOwner->ContentShellRemoved(aContentShell);
@@ -270,61 +270,61 @@ NS_IMETHODIMP
 nsDocShellTreeOwner::GetPrimaryContentShell(nsIDocShellTreeItem** aShell) {
   NS_ENSURE_ARG_POINTER(aShell);
 
   if (mTreeOwner) {
     return mTreeOwner->GetPrimaryContentShell(aShell);
   }
 
   nsCOMPtr<nsIDocShellTreeItem> shell;
-  if (!mPrimaryTabParent) {
+  if (!mPrimaryRemoteTab) {
     shell =
         mPrimaryContentShell ? mPrimaryContentShell : mWebBrowser->mDocShell;
   }
   shell.forget(aShell);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDocShellTreeOwner::TabParentAdded(nsITabParent* aTab, bool aPrimary) {
+nsDocShellTreeOwner::RemoteTabAdded(nsIRemoteTab* aTab, bool aPrimary) {
   if (mTreeOwner) {
-    return mTreeOwner->TabParentAdded(aTab, aPrimary);
+    return mTreeOwner->RemoteTabAdded(aTab, aPrimary);
   }
 
   if (aPrimary) {
-    mPrimaryTabParent = aTab;
+    mPrimaryRemoteTab = aTab;
     mPrimaryContentShell = nullptr;
-  } else if (mPrimaryTabParent == aTab) {
-    mPrimaryTabParent = nullptr;
+  } else if (mPrimaryRemoteTab == aTab) {
+    mPrimaryRemoteTab = nullptr;
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDocShellTreeOwner::TabParentRemoved(nsITabParent* aTab) {
+nsDocShellTreeOwner::RemoteTabRemoved(nsIRemoteTab* aTab) {
   if (mTreeOwner) {
-    return mTreeOwner->TabParentRemoved(aTab);
+    return mTreeOwner->RemoteTabRemoved(aTab);
   }
 
-  if (aTab == mPrimaryTabParent) {
-    mPrimaryTabParent = nullptr;
+  if (aTab == mPrimaryRemoteTab) {
+    mPrimaryRemoteTab = nullptr;
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDocShellTreeOwner::GetPrimaryTabParent(nsITabParent** aTab) {
+nsDocShellTreeOwner::GetPrimaryRemoteTab(nsIRemoteTab** aTab) {
   if (mTreeOwner) {
-    return mTreeOwner->GetPrimaryTabParent(aTab);
+    return mTreeOwner->GetPrimaryRemoteTab(aTab);
   }
 
-  nsCOMPtr<nsITabParent> tab = mPrimaryTabParent;
+  nsCOMPtr<nsIRemoteTab> tab = mPrimaryRemoteTab;
   tab.forget(aTab);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShellTreeOwner::GetPrimaryContentSize(int32_t* aWidth, int32_t* aHeight) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
@@ -351,29 +351,30 @@ nsDocShellTreeOwner::SizeShellTo(nsIDocS
 
   NS_ENSURE_STATE(mTreeOwner || webBrowserChrome);
 
   if (nsCOMPtr<nsIDocShellTreeOwner> treeOwner = mTreeOwner) {
     return treeOwner->SizeShellTo(aShellItem, aCX, aCY);
   }
 
   if (aShellItem == mWebBrowser->mDocShell) {
-    nsCOMPtr<nsITabChild> tabChild = do_QueryInterface(webBrowserChrome);
-    if (tabChild) {
+    nsCOMPtr<nsIBrowserChild> browserChild =
+        do_QueryInterface(webBrowserChrome);
+    if (browserChild) {
       // The XUL window to resize is in the parent process, but there we
       // won't be able to get aShellItem to do the hack in
       // nsXULWindow::SizeShellTo, so let's send the width and height of
       // aShellItem too.
       nsCOMPtr<nsIBaseWindow> shellAsWin(do_QueryInterface(aShellItem));
       NS_ENSURE_TRUE(shellAsWin, NS_ERROR_FAILURE);
 
       int32_t width = 0;
       int32_t height = 0;
       shellAsWin->GetSize(&width, &height);
-      return tabChild->RemoteSizeShellTo(aCX, aCY, width, height);
+      return browserChild->RemoteSizeShellTo(aCX, aCY, width, height);
     }
     // XXX: this is weird, but we used to call a method here
     // (webBrowserChrome->SizeBrowserTo()) whose implementations all failed
     // like this, so...
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   NS_ENSURE_TRUE(aShellItem, NS_ERROR_FAILURE);
@@ -425,17 +426,17 @@ nsDocShellTreeOwner::GetTabCount(uint32_
   }
 
   *aResult = 0;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShellTreeOwner::GetHasPrimaryContent(bool* aResult) {
-  *aResult = mPrimaryTabParent || mPrimaryContentShell;
+  *aResult = mPrimaryRemoteTab || mPrimaryContentShell;
   return NS_OK;
 }
 
 //*****************************************************************************
 // nsDocShellTreeOwner::nsIBaseWindow
 //*****************************************************************************
 
 NS_IMETHODIMP
@@ -879,20 +880,20 @@ nsDocShellTreeOwner::HandleEvent(Event* 
       if (linksCount >= 1) {
         nsCOMPtr<nsIPrincipal> triggeringPrincipal;
         handler->GetTriggeringPrincipal(dragEvent,
                                         getter_AddRefs(triggeringPrincipal));
         if (triggeringPrincipal) {
           nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome =
               GetWebBrowserChrome();
           if (webBrowserChrome) {
-            nsCOMPtr<nsITabChild> tabChild =
+            nsCOMPtr<nsIBrowserChild> browserChild =
                 do_QueryInterface(webBrowserChrome);
-            if (tabChild) {
-              nsresult rv = tabChild->RemoteDropLinks(linksCount, links);
+            if (browserChild) {
+              nsresult rv = browserChild->RemoteDropLinks(linksCount, links);
               for (uint32_t i = 0; i < linksCount; i++) {
                 NS_RELEASE(links[i]);
               }
               free(links);
               return rv;
             }
           }
           nsAutoString url;
--- a/docshell/base/nsDocShellTreeOwner.h
+++ b/docshell/base/nsDocShellTreeOwner.h
@@ -102,17 +102,17 @@ class nsDocShellTreeOwner final : public
   // They are separate objects to avoid circular references between |this|
   // and the DOM.
   RefPtr<ChromeTooltipListener> mChromeTooltipListener;
 
   RefPtr<nsDocShellTreeOwner> mContentTreeOwner;
 
   nsCOMPtr<nsIPrompt> mPrompter;
   nsCOMPtr<nsIAuthPrompt> mAuthPrompter;
-  nsCOMPtr<nsITabParent> mPrimaryTabParent;
+  nsCOMPtr<nsIRemoteTab> mPrimaryRemoteTab;
 };
 
 // The class that listens to the chrome events and tells the embedding chrome to
 // show tooltips, as appropriate. Handles registering itself with the DOM with
 // AddChromeListeners() and removing itself with RemoveChromeListeners().
 class ChromeTooltipListener final : public nsIDOMEventListener {
  protected:
   virtual ~ChromeTooltipListener();
--- a/docshell/base/nsIDocShell.idl
+++ b/docshell/base/nsIDocShell.idl
@@ -55,21 +55,21 @@ interface nsISecureBrowserUI;
 interface nsIScriptGlobalObject;
 interface nsIStructuredCloneContainer;
 interface nsIDOMStorage;
 interface nsIPrincipal;
 interface nsIWebBrowserPrint;
 interface nsIPrivacyTransitionObserver;
 interface nsIReflowObserver;
 interface nsIScrollObserver;
-interface nsITabParent;
-interface nsITabChild;
+interface nsIRemoteTab;
+interface nsIBrowserChild;
 interface nsICommandParams;
 interface nsILoadURIDelegate;
-native TabChildRef(already_AddRefed<nsITabChild>);
+native BrowserChildRef(already_AddRefed<nsIBrowserChild>);
 native nsDocShellLoadStatePtr(nsDocShellLoadState*);
 
 webidl BrowsingContext;
 webidl ContentFrameMessageManager;
 webidl EventTarget;
 webidl Document;
 
 [scriptable, builtinclass, uuid(049234fe-da10-478b-bc5d-bc6f9a1ba63d)]
@@ -943,18 +943,18 @@ interface nsIDocShell : nsIDocShellTreeI
   [infallible] attribute boolean deviceSizeIsPageSize;
 
   /**
    * Regarding setOpener / getOpener - We can't use XPIDL's "attribute"
    * for notxpcom, so we're relegated to using explicit gets / sets. This
    * should be fine, considering that these methods should only ever be
    * called from native code.
    */
-  [noscript,notxpcom,nostdcall] void setOpener(in nsITabParent aOpener);
-  [noscript,notxpcom,nostdcall] nsITabParent getOpener();
+  [noscript,notxpcom,nostdcall] void setOpener(in nsIRemoteTab aOpener);
+  [noscript,notxpcom,nostdcall] nsIRemoteTab getOpener();
 
   /**
    * Notify DocShell when the browser is about to start executing JS, and after
    * that execution has stopped.  This only occurs when the Timeline devtool
    * is collecting information.
    */
   [noscript,notxpcom,nostdcall] void notifyJSRunToCompletionStart(in string aReason,
                                                                   in wstring functionName,
@@ -995,20 +995,20 @@ interface nsIDocShell : nsIDocShellTreeI
   void setOriginAttributes(in jsval aAttrs);
 
   /**
    * The editing session for this docshell.
    */
   readonly attribute nsIEditingSession editingSession;
 
   /**
-   * The tab child for this docshell.
+   * The browser child for this docshell.
    */
-  [binaryname(ScriptableTabChild)] readonly attribute nsITabChild tabChild;
-  [noscript,notxpcom,nostdcall] TabChildRef GetTabChild();
+  [binaryname(ScriptableBrowserChild)] readonly attribute nsIBrowserChild browserChild;
+  [noscript,notxpcom,nostdcall] BrowserChildRef GetBrowserChild();
 
   [noscript,nostdcall,notxpcom] nsCommandManager GetCommandManager();
 
   cenum TouchEventsOverride: 8 {
     /**
      * Override platform/pref default behaviour and force-disable touch events.
      */
     TOUCHEVENTS_OVERRIDE_DISABLED = 0,
--- a/docshell/base/nsIDocShellTreeOwner.idl
+++ b/docshell/base/nsIDocShellTreeOwner.idl
@@ -6,17 +6,17 @@
 
 #include "nsISupports.idl"
 
 /**
  * The nsIDocShellTreeOwner
  */
 
 interface nsIDocShellTreeItem;
-interface nsITabParent;
+interface nsIRemoteTab;
 
 [scriptable, uuid(0e3dc4b1-4cea-4a37-af71-79f0afd07574)]
 interface nsIDocShellTreeOwner : nsISupports
 {
 	/**
 	 * Called when a content shell is added to the docshell tree.  This is
 	 * _only_ called for "root" content shells (that is, ones whose parent is a
 	 * chrome shell).
@@ -37,24 +37,24 @@ interface nsIDocShellTreeOwner : nsISupp
 	 */
 	void contentShellRemoved(in nsIDocShellTreeItem aContentShell);
 
 	/*
 	Returns the Primary Content Shell
 	*/
 	readonly attribute nsIDocShellTreeItem primaryContentShell;
 
-	void tabParentAdded(in nsITabParent aTab, in boolean aPrimary);
-	void tabParentRemoved(in nsITabParent aTab);
+	void remoteTabAdded(in nsIRemoteTab aTab, in boolean aPrimary);
+	void remoteTabRemoved(in nsIRemoteTab aTab);
 
 	/*
 	In multiprocess case we may not have primaryContentShell but
-	primaryTabParent.
+	primaryRemoteTab.
 	 */
-	readonly attribute nsITabParent primaryTabParent;
+	readonly attribute nsIRemoteTab primaryRemoteTab;
 
 	/*
 	Tells the tree owner to size its window or parent window in such a way
 	that the shell passed along will be the size specified.
 	*/
 	[can_run_script]
 	void sizeShellTo(in nsIDocShellTreeItem shell, in long cx, in long cy);
 
@@ -95,12 +95,12 @@ interface nsIDocShellTreeOwner : nsISupp
 	/*
 	Gets the number of tabs currently open in our window, assuming
 	this tree owner has such a concept.
 	*/
 	readonly attribute unsigned long tabCount;
 
 	/*
 	Returns true if there is a primary content shell or a primary
-	tab parent.
+	remote tab.
 	*/
 	readonly attribute bool hasPrimaryContent;
 };
--- a/docshell/shistory/ChildSHistory.cpp
+++ b/docshell/shistory/ChildSHistory.cpp
@@ -78,17 +78,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(ChildSH
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ChildSHistory, mDocShell, mHistory)
 
 JSObject* ChildSHistory::WrapObject(JSContext* cx,
                                     JS::Handle<JSObject*> aGivenProto) {
   return ChildSHistory_Binding::Wrap(cx, this, aGivenProto);
 }
 
 nsISupports* ChildSHistory::GetParentObject() const {
-  // We want to get the TabChildMessageManager, which is the
+  // We want to get the BrowserChildMessageManager, which is the
   // messageManager on mDocShell.
   RefPtr<ContentFrameMessageManager> mm;
   if (mDocShell) {
     mm = mDocShell->GetMessageManager();
   }
   // else we must be unlinked... can that happen here?
   return ToSupports(mm);
 }
--- a/docshell/shistory/ParentSHistory.cpp
+++ b/docshell/shistory/ParentSHistory.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "mozilla/dom/ParentSHistory.h"
 #include "mozilla/dom/ParentSHistoryBinding.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "nsDocShell.h"
 #include "nsFrameLoader.h"
 #include "nsXULAppAPI.h"
 
 namespace mozilla {
 namespace dom {
 
 ParentSHistory::ParentSHistory(nsFrameLoader* aFrameLoader)
@@ -20,18 +20,18 @@ ParentSHistory::ParentSHistory(nsFrameLo
 }
 
 ParentSHistory::~ParentSHistory() {}
 
 nsDocShell* ParentSHistory::GetDocShell() {
   return nsDocShell::Cast(mFrameLoader->GetExistingDocShell());
 }
 
-TabParent* ParentSHistory::GetTabParent() {
-  return static_cast<TabParent*>(mFrameLoader->GetRemoteBrowser());
+BrowserParent* ParentSHistory::GetBrowserParent() {
+  return static_cast<BrowserParent*>(mFrameLoader->GetRemoteBrowser());
 }
 
 already_AddRefed<ChildSHistory> ParentSHistory::GetChildIfSameProcess() {
   if (GetDocShell()) {
     return GetDocShell()->GetSessionHistory();
   }
 
   return nullptr;
--- a/docshell/shistory/ParentSHistory.h
+++ b/docshell/shistory/ParentSHistory.h
@@ -24,17 +24,17 @@
 #include "mozilla/ErrorResult.h"
 #include "nsWrapperCache.h"
 
 class nsDocShell;
 
 namespace mozilla {
 namespace dom {
 
-class TabParent;
+class BrowserParent;
 class ChildSHistory;
 
 class ParentSHistory : public nsISupports, public nsWrapperCache {
  public:
   friend class ChildSHistory;
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ParentSHistory)
@@ -45,17 +45,17 @@ class ParentSHistory : public nsISupport
   explicit ParentSHistory(nsFrameLoader* aFrameLoader);
 
   // XXX(nika): Implement
   int32_t Count() { return 0; }
   int32_t Index() { return 0; }
 
  private:
   nsDocShell* GetDocShell();
-  TabParent* GetTabParent();
+  BrowserParent* GetBrowserParent();
 
   already_AddRefed<ChildSHistory> GetChildIfSameProcess();
 
   virtual ~ParentSHistory();
 
   RefPtr<nsFrameLoader> mFrameLoader;
 };
 
--- a/dom/base/Document.cpp
+++ b/dom/base/Document.cpp
@@ -84,17 +84,17 @@
 #include "mozilla/net/CookieSettings.h"
 #include "nsGenericHTMLElement.h"
 #include "mozilla/dom/CDATASection.h"
 #include "mozilla/dom/ProcessingInstruction.h"
 #include "nsDOMString.h"
 #include "nsNodeUtils.h"
 #include "nsLayoutUtils.h"  // for GetFrameForPoint
 #include "nsIFrame.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 
 #include "nsRange.h"
 #include "mozilla/dom/DocumentType.h"
 #include "mozilla/dom/NodeIterator.h"
 #include "mozilla/dom/Promise.h"
 #include "mozilla/dom/PromiseNativeHandler.h"
 #include "mozilla/dom/TreeWalker.h"
 
@@ -230,17 +230,17 @@
 #include "mozilla/dom/DocumentTimeline.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/HTMLBodyElement.h"
 #include "mozilla/dom/HTMLInputElement.h"
 #include "mozilla/dom/ImageTracker.h"
 #include "mozilla/dom/MediaQueryList.h"
 #include "mozilla/dom/NodeFilterBinding.h"
 #include "mozilla/OwningNonNull.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/WebComponentsBinding.h"
 #include "mozilla/dom/CustomElementRegistryBinding.h"
 #include "mozilla/dom/CustomElementRegistry.h"
 #include "mozilla/dom/ServiceWorkerDescriptor.h"
 #include "mozilla/dom/TimeoutManager.h"
 #include "mozilla/ExtensionPolicyService.h"
 #include "nsFrame.h"
 #include "nsDOMCaretPosition.h"
@@ -1029,17 +1029,17 @@ IMPL_SHIM(nsIApplicationCacheContainer)
     return NS_OK;                                    \
   }                                                  \
   PR_END_MACRO
 
 NS_IMETHODIMP
 ExternalResourceMap::LoadgroupCallbacks::GetInterface(const nsIID& aIID,
                                                       void** aSink) {
   if (mCallbacks && (IID_IS(nsIPrompt) || IID_IS(nsIAuthPrompt) ||
-                     IID_IS(nsIAuthPrompt2) || IID_IS(nsITabChild))) {
+                     IID_IS(nsIAuthPrompt2) || IID_IS(nsIBrowserChild))) {
     return mCallbacks->GetInterface(aIID, aSink);
   }
 
   *aSink = nullptr;
 
   TRY_SHIM(nsILoadContext);
   TRY_SHIM(nsIProgressEventSink);
   TRY_SHIM(nsIChannelEventSink);
rename from dom/base/InProcessTabChildMessageManager.cpp
rename to dom/base/InProcessBrowserChildMessageManager.cpp
--- a/dom/base/InProcessTabChildMessageManager.cpp
+++ b/dom/base/InProcessBrowserChildMessageManager.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "InProcessTabChildMessageManager.h"
+#include "InProcessBrowserChildMessageManager.h"
 #include "nsContentUtils.h"
 #include "nsDocShell.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsIComponentManager.h"
 #include "nsIServiceManager.h"
 #include "nsComponentManagerUtils.h"
 #include "nsFrameLoader.h"
@@ -23,17 +23,17 @@
 #include "mozilla/dom/SameProcessMessageQueue.h"
 #include "mozilla/dom/ScriptLoader.h"
 #include "mozilla/dom/WindowProxyHolder.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::dom::ipc;
 
-bool InProcessTabChildMessageManager::DoSendBlockingMessage(
+bool InProcessBrowserChildMessageManager::DoSendBlockingMessage(
     JSContext* aCx, const nsAString& aMessage, StructuredCloneData& aData,
     JS::Handle<JSObject*> aCpows, nsIPrincipal* aPrincipal,
     nsTArray<StructuredCloneData>* aRetVal, bool aIsSync) {
   SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
   queue->Flush();
 
   if (mChromeMessageManager) {
     SameProcessCpowHolder cpows(JS::RootingContext::get(aCx), aCpows);
@@ -45,46 +45,47 @@ bool InProcessTabChildMessageManager::Do
   return true;
 }
 
 class nsAsyncMessageToParent : public nsSameProcessAsyncMessageBase,
                                public SameProcessMessageQueue::Runnable {
  public:
   nsAsyncMessageToParent(JS::RootingContext* aRootingCx,
                          JS::Handle<JSObject*> aCpows,
-                         InProcessTabChildMessageManager* aTabChild)
+                         InProcessBrowserChildMessageManager* aBrowserChild)
       : nsSameProcessAsyncMessageBase(aRootingCx, aCpows),
-        mTabChild(aTabChild) {}
+        mBrowserChild(aBrowserChild) {}
 
   virtual nsresult HandleMessage() override {
-    RefPtr<nsFrameLoader> fl = mTabChild->GetFrameLoader();
-    ReceiveMessage(mTabChild->mOwner, fl, mTabChild->mChromeMessageManager);
+    RefPtr<nsFrameLoader> fl = mBrowserChild->GetFrameLoader();
+    ReceiveMessage(mBrowserChild->mOwner, fl,
+                   mBrowserChild->mChromeMessageManager);
     return NS_OK;
   }
-  RefPtr<InProcessTabChildMessageManager> mTabChild;
+  RefPtr<InProcessBrowserChildMessageManager> mBrowserChild;
 };
 
-nsresult InProcessTabChildMessageManager::DoSendAsyncMessage(
+nsresult InProcessBrowserChildMessageManager::DoSendAsyncMessage(
     JSContext* aCx, const nsAString& aMessage, StructuredCloneData& aData,
     JS::Handle<JSObject*> aCpows, nsIPrincipal* aPrincipal) {
   SameProcessMessageQueue* queue = SameProcessMessageQueue::Get();
   JS::RootingContext* rcx = JS::RootingContext::get(aCx);
   RefPtr<nsAsyncMessageToParent> ev =
       new nsAsyncMessageToParent(rcx, aCpows, this);
 
   nsresult rv = ev->Init(aMessage, aData, aPrincipal);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   queue->Push(ev);
   return NS_OK;
 }
 
-InProcessTabChildMessageManager::InProcessTabChildMessageManager(
+InProcessBrowserChildMessageManager::InProcessBrowserChildMessageManager(
     nsDocShell* aShell, nsIContent* aOwner, nsFrameMessageManager* aChrome)
     : ContentFrameMessageManager(new nsFrameMessageManager(this)),
       mDocShell(aShell),
       mLoadingScript(false),
       mPreventEventsEscaping(false),
       mOwner(aOwner),
       mChromeMessageManager(aChrome) {
   mozilla::HoldJSObjects(this);
@@ -94,83 +95,85 @@ InProcessTabChildMessageManager::InProce
   nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(mOwner);
   if (browserFrame) {
     mIsBrowserFrame = browserFrame->GetReallyIsBrowser();
   } else {
     mIsBrowserFrame = false;
   }
 }
 
-InProcessTabChildMessageManager::~InProcessTabChildMessageManager() {
+InProcessBrowserChildMessageManager::~InProcessBrowserChildMessageManager() {
   mAnonymousGlobalScopes.Clear();
   mozilla::DropJSObjects(this);
 }
 
 // This method isn't automatically forwarded safely because it's notxpcom, so
 // the IDL binding doesn't know what value to return.
-void InProcessTabChildMessageManager::MarkForCC() {
+void InProcessBrowserChildMessageManager::MarkForCC() {
   MarkScopesForCC();
   MessageManagerGlobal::MarkForCC();
 }
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(InProcessTabChildMessageManager)
+NS_IMPL_CYCLE_COLLECTION_CLASS(InProcessBrowserChildMessageManager)
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(
-    InProcessTabChildMessageManager, DOMEventTargetHelper)
+    InProcessBrowserChildMessageManager, DOMEventTargetHelper)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessageManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocShell)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(InProcessTabChildMessageManager,
-                                               DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(
+    InProcessBrowserChildMessageManager, DOMEventTargetHelper)
   tmp->nsMessageManagerScriptExecutor::Trace(aCallbacks, aClosure);
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(InProcessTabChildMessageManager,
-                                                DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(
+    InProcessBrowserChildMessageManager, DOMEventTargetHelper)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessageManager)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocShell)
   tmp->nsMessageManagerScriptExecutor::Unlink();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(InProcessTabChildMessageManager)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(InProcessBrowserChildMessageManager)
   NS_INTERFACE_MAP_ENTRY(nsIMessageSender)
   NS_INTERFACE_MAP_ENTRY(nsIInProcessContentFrameMessageManager)
   NS_INTERFACE_MAP_ENTRY(ContentFrameMessageManager)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 
-NS_IMPL_ADDREF_INHERITED(InProcessTabChildMessageManager, DOMEventTargetHelper)
-NS_IMPL_RELEASE_INHERITED(InProcessTabChildMessageManager, DOMEventTargetHelper)
+NS_IMPL_ADDREF_INHERITED(InProcessBrowserChildMessageManager,
+                         DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(InProcessBrowserChildMessageManager,
+                          DOMEventTargetHelper)
 
-JSObject* InProcessTabChildMessageManager::WrapObject(
+JSObject* InProcessBrowserChildMessageManager::WrapObject(
     JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
   return ContentFrameMessageManager_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-void InProcessTabChildMessageManager::CacheFrameLoader(
+void InProcessBrowserChildMessageManager::CacheFrameLoader(
     nsFrameLoader* aFrameLoader) {
   mFrameLoader = aFrameLoader;
 }
 
-Nullable<WindowProxyHolder> InProcessTabChildMessageManager::GetContent(
+Nullable<WindowProxyHolder> InProcessBrowserChildMessageManager::GetContent(
     ErrorResult& aError) {
   if (!mDocShell) {
     return nullptr;
   }
   return WindowProxyHolder(mDocShell->GetBrowsingContext());
 }
 
 already_AddRefed<nsIEventTarget>
-InProcessTabChildMessageManager::GetTabEventTarget() {
+InProcessBrowserChildMessageManager::GetTabEventTarget() {
   nsCOMPtr<nsIEventTarget> target = GetMainThreadEventTarget();
   return target.forget();
 }
 
-uint64_t InProcessTabChildMessageManager::ChromeOuterWindowID() {
+uint64_t InProcessBrowserChildMessageManager::ChromeOuterWindowID() {
   if (!mDocShell) {
     return 0;
   }
 
   nsCOMPtr<nsIDocShellTreeItem> root;
   nsresult rv = mDocShell->GetRootTreeItem(getter_AddRefs(root));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return 0;
@@ -179,66 +182,66 @@ uint64_t InProcessTabChildMessageManager
   nsPIDOMWindowOuter* topWin = root->GetWindow();
   if (!topWin) {
     return 0;
   }
 
   return topWin->WindowID();
 }
 
-void InProcessTabChildMessageManager::FireUnloadEvent() {
+void InProcessBrowserChildMessageManager::FireUnloadEvent() {
   // We're called from Document::MaybeInitializeFinalizeFrameLoaders, so it
   // should be safe to run script.
   MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
 
   // Don't let the unload event propagate to chrome event handlers.
   mPreventEventsEscaping = true;
   DOMEventTargetHelper::DispatchTrustedEvent(NS_LITERAL_STRING("unload"));
 
   // Allow events fired during docshell destruction (pagehide, unload) to
   // propagate to the <browser> element since chrome code depends on this.
   mPreventEventsEscaping = false;
 }
 
-void InProcessTabChildMessageManager::DisconnectEventListeners() {
+void InProcessBrowserChildMessageManager::DisconnectEventListeners() {
   if (mDocShell) {
     if (nsCOMPtr<nsPIDOMWindowOuter> win = mDocShell->GetWindow()) {
       win->SetChromeEventHandler(win->GetChromeEventHandler());
     }
   }
   if (mListenerManager) {
     mListenerManager->Disconnect();
   }
 
   mDocShell = nullptr;
 }
 
-void InProcessTabChildMessageManager::Disconnect() {
+void InProcessBrowserChildMessageManager::Disconnect() {
   mChromeMessageManager = nullptr;
   mOwner = nullptr;
   if (mMessageManager) {
     static_cast<nsFrameMessageManager*>(mMessageManager.get())->Disconnect();
     mMessageManager = nullptr;
   }
 }
 
 NS_IMETHODIMP_(nsIContent*)
-InProcessTabChildMessageManager::GetOwnerContent() { return mOwner; }
+InProcessBrowserChildMessageManager::GetOwnerContent() { return mOwner; }
 
-void InProcessTabChildMessageManager::GetEventTargetParent(
+void InProcessBrowserChildMessageManager::GetEventTargetParent(
     EventChainPreVisitor& aVisitor) {
   aVisitor.mForceContentDispatch = true;
   aVisitor.mCanHandle = true;
 
 #ifdef DEBUG
   if (mOwner) {
     RefPtr<nsFrameLoaderOwner> owner = do_QueryObject(mOwner);
     RefPtr<nsFrameLoader> fl = owner->GetFrameLoader();
     if (fl) {
-      NS_ASSERTION(this == fl->GetTabChildMessageManager(),
+      NS_ASSERTION(this == fl->GetBrowserChildMessageManager(),
                    "Wrong event target!");
       NS_ASSERTION(fl->mMessageManager == mChromeMessageManager,
                    "Wrong message manager!");
     }
   }
 #endif
 
   if (mPreventEventsEscaping) {
@@ -258,47 +261,47 @@ void InProcessTabChildMessageManager::Ge
     }
   } else {
     aVisitor.SetParentTarget(mOwner, false);
   }
 }
 
 class nsAsyncScriptLoad : public Runnable {
  public:
-  nsAsyncScriptLoad(InProcessTabChildMessageManager* aTabChild,
+  nsAsyncScriptLoad(InProcessBrowserChildMessageManager* aBrowserChild,
                     const nsAString& aURL, bool aRunInGlobalScope)
       : mozilla::Runnable("nsAsyncScriptLoad"),
-        mTabChild(aTabChild),
+        mBrowserChild(aBrowserChild),
         mURL(aURL),
         mRunInGlobalScope(aRunInGlobalScope) {}
 
   NS_IMETHOD Run() override {
-    mTabChild->LoadFrameScript(mURL, mRunInGlobalScope);
+    mBrowserChild->LoadFrameScript(mURL, mRunInGlobalScope);
     return NS_OK;
   }
-  RefPtr<InProcessTabChildMessageManager> mTabChild;
+  RefPtr<InProcessBrowserChildMessageManager> mBrowserChild;
   nsString mURL;
   bool mRunInGlobalScope;
 };
 
-void InProcessTabChildMessageManager::LoadFrameScript(const nsAString& aURL,
-                                                      bool aRunInGlobalScope) {
+void InProcessBrowserChildMessageManager::LoadFrameScript(
+    const nsAString& aURL, bool aRunInGlobalScope) {
   if (!nsContentUtils::IsSafeToRunScript()) {
     nsContentUtils::AddScriptRunner(
         new nsAsyncScriptLoad(this, aURL, aRunInGlobalScope));
     return;
   }
   bool tmp = mLoadingScript;
   mLoadingScript = true;
   JS::Rooted<JSObject*> mm(mozilla::dom::RootingCx(), GetOrCreateWrapper());
   LoadScriptInternal(mm, aURL, !aRunInGlobalScope);
   mLoadingScript = tmp;
 }
 
 already_AddRefed<nsFrameLoader>
-InProcessTabChildMessageManager::GetFrameLoader() {
+InProcessBrowserChildMessageManager::GetFrameLoader() {
   RefPtr<nsFrameLoaderOwner> owner = do_QueryObject(mOwner);
   RefPtr<nsFrameLoader> fl = owner ? owner->GetFrameLoader() : nullptr;
   if (!fl) {
     fl = mFrameLoader;
   }
   return fl.forget();
 }
rename from dom/base/InProcessTabChildMessageManager.h
rename to dom/base/InProcessBrowserChildMessageManager.h
--- a/dom/base/InProcessTabChildMessageManager.h
+++ b/dom/base/InProcessBrowserChildMessageManager.h
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-#ifndef nsInProcessTabChildGlobal_h
-#define nsInProcessTabChildGlobal_h
+#ifndef nsInProcessBrowserChildGlobal_h
+#define nsInProcessBrowserChildGlobal_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/DOMEventTargetHelper.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/dom/ContentFrameMessageManager.h"
 #include "nsCOMPtr.h"
 #include "nsFrameMessageManager.h"
 #include "nsIScriptContext.h"
@@ -24,46 +24,46 @@
 
 namespace mozilla {
 class EventChainPreVisitor;
 
 namespace dom {
 
 /**
  * This class implements a ContentFrameMessageManager for use by frame loaders
- * in the parent process. It is bound to a DocShell rather than a TabChild, and
- * does not use any IPC infrastructure for its message passing.
+ * in the parent process. It is bound to a DocShell rather than a BrowserChild,
+ * and does not use any IPC infrastructure for its message passing.
  */
 
-class InProcessTabChildMessageManager final
+class InProcessBrowserChildMessageManager final
     : public ContentFrameMessageManager,
       public nsMessageManagerScriptExecutor,
       public nsIInProcessContentFrameMessageManager,
       public nsSupportsWeakReference,
       public mozilla::dom::ipc::MessageManagerCallback {
   typedef mozilla::dom::ipc::StructuredCloneData StructuredCloneData;
 
  private:
-  InProcessTabChildMessageManager(nsDocShell* aShell, nsIContent* aOwner,
-                                  nsFrameMessageManager* aChrome);
+  InProcessBrowserChildMessageManager(nsDocShell* aShell, nsIContent* aOwner,
+                                      nsFrameMessageManager* aChrome);
 
  public:
-  static already_AddRefed<InProcessTabChildMessageManager> Create(
+  static already_AddRefed<InProcessBrowserChildMessageManager> Create(
       nsDocShell* aShell, nsIContent* aOwner, nsFrameMessageManager* aChrome) {
-    RefPtr<InProcessTabChildMessageManager> mm =
-        new InProcessTabChildMessageManager(aShell, aOwner, aChrome);
+    RefPtr<InProcessBrowserChildMessageManager> mm =
+        new InProcessBrowserChildMessageManager(aShell, aOwner, aChrome);
 
     NS_ENSURE_TRUE(mm->Init(), nullptr);
 
     return mm.forget();
   }
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(
-      InProcessTabChildMessageManager, DOMEventTargetHelper)
+      InProcessBrowserChildMessageManager, DOMEventTargetHelper)
 
   void MarkForCC();
 
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
   Nullable<WindowProxyHolder> GetContent(ErrorResult& aError) override;
   virtual already_AddRefed<nsIDocShell> GetDocShell(
@@ -112,17 +112,17 @@ class InProcessTabChildMessageManager fi
   }
   void SetChromeMessageManager(nsFrameMessageManager* aParent) {
     mChromeMessageManager = aParent;
   }
 
   already_AddRefed<nsFrameLoader> GetFrameLoader();
 
  protected:
-  virtual ~InProcessTabChildMessageManager();
+  virtual ~InProcessBrowserChildMessageManager();
 
   RefPtr<nsDocShell> mDocShell;
   bool mLoadingScript;
 
   // Is this the message manager for an in-process <iframe mozbrowser>? This
   // affects where events get sent, so it affects GetEventTargetParent.
   bool mIsBrowserFrame;
   bool mPreventEventsEscaping;
--- a/dom/base/Navigator.cpp
+++ b/dom/base/Navigator.cpp
@@ -70,17 +70,17 @@
 #include "nsIHttpChannel.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsStreamUtils.h"
 #include "WidgetUtils.h"
 #include "nsIPresentationService.h"
 #include "nsIScriptError.h"
 
 #include "nsIExternalProtocolHandler.h"
-#include "TabChild.h"
+#include "BrowserChild.h"
 #include "URIUtils.h"
 
 #include "mozilla/dom/MediaDevices.h"
 #include "MediaManager.h"
 
 #include "nsIDOMGlobalPropertyInitializer.h"
 #include "nsJSUtils.h"
 
@@ -969,18 +969,19 @@ void Navigator::RegisterProtocolHandler(
   CheckProtocolHandlerAllowed(aScheme, handlerURI, docURI, aRv);
   if (aRv.Failed()) {
     return;
   }
 
   if (XRE_IsContentProcess()) {
     nsAutoString scheme(aScheme);
     nsAutoString title(aTitle);
-    RefPtr<TabChild> tabChild = TabChild::GetFrom(mWindow);
-    tabChild->SendRegisterProtocolHandler(scheme, handlerURI, title, docURI);
+    RefPtr<BrowserChild> browserChild = BrowserChild::GetFrom(mWindow);
+    browserChild->SendRegisterProtocolHandler(scheme, handlerURI, title,
+                                              docURI);
     return;
   }
 
   nsCOMPtr<nsIWebProtocolHandlerRegistrar> registrar =
       do_GetService(NS_WEBPROTOCOLHANDLERREGISTRAR_CONTRACTID);
   if (registrar) {
     aRv = registrar->RegisterProtocolHandler(aScheme, handlerURI, aTitle,
                                              docURI, mWindow->GetOuterWindow());
--- a/dom/base/TabGroup.cpp
+++ b/dom/base/TabGroup.cpp
@@ -2,17 +2,17 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "mozilla/dom/TabGroup.h"
 
 #include "mozilla/dom/ContentChild.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/DocGroup.h"
 #include "mozilla/dom/TimeoutManager.h"
 #include "mozilla/AbstractThread.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/ThrottledEventQueue.h"
 #include "nsIDocShell.h"
@@ -92,34 +92,34 @@ TabGroup* TabGroup::GetChromeTabGroup() 
     sChromeTabGroup = new TabGroup(true /* chrome tab group */);
     ClearOnShutdown(&sChromeTabGroup);
   }
   return sChromeTabGroup;
 }
 
 /* static */
 TabGroup* TabGroup::GetFromWindow(mozIDOMWindowProxy* aWindow) {
-  if (TabChild* tabChild = TabChild::GetFrom(aWindow)) {
-    return tabChild->TabGroup();
+  if (BrowserChild* browserChild = BrowserChild::GetFrom(aWindow)) {
+    return browserChild->TabGroup();
   }
 
   return nullptr;
 }
 
 /* static */
-TabGroup* TabGroup::GetFromActor(TabChild* aTabChild) {
+TabGroup* TabGroup::GetFromActor(BrowserChild* aBrowserChild) {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 
   // Middleman processes do not assign event targets to their tab children.
   if (recordreplay::IsMiddleman()) {
     return GetChromeTabGroup();
   }
 
   nsCOMPtr<nsIEventTarget> target =
-      aTabChild->Manager()->GetEventTargetFor(aTabChild);
+      aBrowserChild->Manager()->GetEventTargetFor(aBrowserChild);
   if (!target) {
     return nullptr;
   }
 
   // We have an event target. We assume the IPC code created it via
   // TabGroup::CreateEventTarget.
   RefPtr<SchedulerGroup> group = SchedulerGroup::FromEventTarget(target);
   MOZ_RELEASE_ASSERT(group);
--- a/dom/base/TabGroup.h
+++ b/dom/base/TabGroup.h
@@ -20,17 +20,17 @@
 class mozIDOMWindowProxy;
 class nsIDocShellTreeItem;
 class nsPIDOMWindowOuter;
 
 namespace mozilla {
 class AbstractThread;
 namespace dom {
 class Document;
-class TabChild;
+class BrowserChild;
 
 // Two browsing contexts are considered "related" if they are reachable from one
 // another through window.opener, window.parent, or window.frames. This is the
 // spec concept of a "unit of related browsing contexts"
 //
 // Two browsing contexts are considered "similar-origin" if they can be made to
 // have the same origin by setting document.domain. This is the spec concept of
 // a "unit of similar-origin related browsing contexts"
@@ -38,17 +38,17 @@ class TabChild;
 // A TabGroup is a set of browsing contexts which are all "related". Within a
 // TabGroup, browsing contexts are broken into "similar-origin" DocGroups. In
 // more detail, a DocGroup is actually a collection of documents, and a
 // TabGroup is a collection of DocGroups. A TabGroup typically will contain
 // (through its DocGroups) the documents from one or more tabs related by
 // window.opener. A DocGroup is a member of exactly one TabGroup.
 
 class DocGroup;
-class TabChild;
+class BrowserChild;
 
 class TabGroup final : public SchedulerGroup,
                        public LinkedListElement<TabGroup> {
  private:
   class HashEntry : public nsCStringHashKey {
    public:
     // NOTE: Weak reference. The DocGroup destructor removes itself from its
     // owning TabGroup.
@@ -62,21 +62,21 @@ class TabGroup final : public SchedulerG
   typedef DocGroupMap::Iterator Iterator;
 
   friend class DocGroup;
 
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TabGroup, override)
 
   static TabGroup* GetChromeTabGroup();
 
-  // Checks if the TabChild already has a TabGroup assigned to it in
+  // Checks if the BrowserChild already has a TabGroup assigned to it in
   // IPDL. Returns this TabGroup if it does. This could happen if the parent
   // process created the PBrowser and we needed to assign a TabGroup immediately
   // upon receiving the IPDL message. This method is main thread only.
-  static TabGroup* GetFromActor(TabChild* aTabChild);
+  static TabGroup* GetFromActor(BrowserChild* aBrowserChild);
 
   static TabGroup* GetFromWindow(mozIDOMWindowProxy* aWindow);
 
   explicit TabGroup(bool aIsChrome = false);
 
   // Get the docgroup for the corresponding doc group key.
   // Returns null if the given key hasn't been seen yet.
   already_AddRefed<DocGroup> GetDocGroup(const nsACString& aKey);
--- a/dom/base/TextInputProcessor.cpp
+++ b/dom/base/TextInputProcessor.cpp
@@ -984,17 +984,17 @@ nsresult TextInputProcessor::PrepareKeyb
         WidgetKeyboardEvent::ComputeKeyCodeFromKeyNameIndex(
             aKeyboardEvent.mKeyNameIndex);
   }
 
   aKeyboardEvent.mIsSynthesizedByTIP = !mForTests;
 
   // When this emulates real input only in content process, we need to
   // initialize edit commands with the main process's widget via PuppetWidget
-  // because they are initialized by TabParent before content process treats
+  // because they are initialized by BrowserParent before content process treats
   // them.
   if (aKeyboardEvent.mIsSynthesizedByTIP && !XRE_IsParentProcess()) {
     // Note that retrieving edit commands from content process is expensive.
     // Let's skip it when the keyboard event is inputting text.
     if (!aKeyboardEvent.IsInputtingText()) {
       // FYI: WidgetKeyboardEvent::InitAllEditCommands() isn't available here
       //      since it checks whether it's called in the main process to
       //      avoid performance issues so that we need to initialize each
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -294,17 +294,17 @@ UNIFIED_SOURCES += [
     'FormData.cpp',
     'FragmentOrElement.cpp',
     'GeneratedImageContent.cpp',
     'IdleDeadline.cpp',
     'IdleRequest.cpp',
     'IDTracker.cpp',
     'ImageEncoder.cpp',
     'ImageTracker.cpp',
-    'InProcessTabChildMessageManager.cpp',
+    'InProcessBrowserChildMessageManager.cpp',
     'IntlUtils.cpp',
     'Link.cpp',
     'Location.cpp',
     'MaybeCrossOriginObject.cpp',
     'MessageBroadcaster.cpp',
     'MessageListenerManager.cpp',
     'MessageManagerGlobal.cpp',
     'MessageSender.cpp',
--- a/dom/base/nsCCUncollectableMarker.cpp
+++ b/dom/base/nsCCUncollectableMarker.cpp
@@ -6,17 +6,17 @@
 
 #include "nsCCUncollectableMarker.h"
 #include "nsIObserverService.h"
 #include "nsIDocShell.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIContentViewer.h"
 #include "mozilla/dom/Document.h"
 #include "XULDocument.h"
-#include "InProcessTabChildMessageManager.h"
+#include "InProcessBrowserChildMessageManager.h"
 #include "nsIWindowMediator.h"
 #include "nsPIDOMWindow.h"
 #include "nsIWebNavigation.h"
 #include "nsISHistory.h"
 #include "nsISHEntry.h"
 #include "nsIWindowWatcher.h"
 #include "mozilla/Services.h"
 #include "nsIXULWindow.h"
@@ -29,17 +29,17 @@
 #include "mozilla/CycleCollectedJSContext.h"
 #include "mozilla/CycleCollectedJSRuntime.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/ChromeMessageBroadcaster.h"
 #include "mozilla/dom/ContentFrameMessageManager.h"
 #include "mozilla/dom/ContentProcessMessageManager.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/ParentProcessMessageManager.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/TimeoutManager.h"
 #include "xpcpublic.h"
 #include "nsObserverService.h"
 #include "nsFocusManager.h"
 #include "nsIInterfaceRequestorUtils.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
@@ -81,18 +81,18 @@ nsresult nsCCUncollectableMarker::Init()
   sInited = true;
 
   return NS_OK;
 }
 
 static void MarkChildMessageManagers(MessageBroadcaster* aMM) {
   aMM->MarkForCC();
 
-  uint32_t tabChildCount = aMM->ChildCount();
-  for (uint32_t j = 0; j < tabChildCount; ++j) {
+  uint32_t browserChildCount = aMM->ChildCount();
+  for (uint32_t j = 0; j < browserChildCount; ++j) {
     RefPtr<MessageListenerManager> childMM = aMM->GetChildAt(j);
     if (!childMM) {
       continue;
     }
 
     RefPtr<MessageBroadcaster> strongNonLeafMM =
         MessageBroadcaster::From(childMM);
     MessageBroadcaster* nonLeafMM = strongNonLeafMM;
@@ -109,17 +109,18 @@ static void MarkChildMessageManagers(Mes
 
     tabMM->MarkForCC();
 
     // XXX hack warning, but works, since we know that
     //    callback is frameloader.
     mozilla::dom::ipc::MessageManagerCallback* cb = tabMM->GetCallback();
     if (cb) {
       nsFrameLoader* fl = static_cast<nsFrameLoader*>(cb);
-      InProcessTabChildMessageManager* et = fl->GetTabChildMessageManager();
+      InProcessBrowserChildMessageManager* et =
+          fl->GetBrowserChildMessageManager();
       if (!et) {
         continue;
       }
       et->MarkForCC();
       EventListenerManager* elm = et->GetExistingListenerManager();
       if (elm) {
         elm->MarkForCC();
       }
@@ -267,19 +268,20 @@ void MarkDocShell(nsIDocShellTreeItem* a
 void MarkWindowList(nsISimpleEnumerator* aWindowList, bool aCleanupJS) {
   nsCOMPtr<nsISupports> iter;
   while (NS_SUCCEEDED(aWindowList->GetNext(getter_AddRefs(iter))) && iter) {
     if (nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(iter)) {
       nsCOMPtr<nsIDocShell> rootDocShell = window->GetDocShell();
 
       MarkDocShell(rootDocShell, aCleanupJS);
 
-      RefPtr<TabChild> tabChild = TabChild::GetFrom(rootDocShell);
-      if (tabChild) {
-        RefPtr<TabChildMessageManager> mm = tabChild->GetMessageManager();
+      RefPtr<BrowserChild> browserChild = BrowserChild::GetFrom(rootDocShell);
+      if (browserChild) {
+        RefPtr<BrowserChildMessageManager> mm =
+            browserChild->GetMessageManager();
         if (mm) {
           // MarkForCC ends up calling UnmarkGray on message listeners, which
           // TraceBlackJS can't do yet.
           mm->MarkForCC();
         }
       }
     }
   }
@@ -476,29 +478,30 @@ void mozilla::dom::TraceBlackJS(JSTracer
             EventListenerManager* elm = inner->GetExistingListenerManager();
             if (elm) {
               elm->TraceListeners(aTrc);
             }
           }
         }
 
         if (window->IsRootOuterWindow()) {
-          // In child process trace all the TabChildMessageManagers.
-          // Since there is one root outer window per TabChildMessageManager, we
-          // need to look for only those windows, not all.
+          // In child process trace all the BrowserChildMessageManagers.
+          // Since there is one root outer window per
+          // BrowserChildMessageManager, we need to look for only those windows,
+          // not all.
           nsIDocShell* ds = window->GetDocShell();
           if (ds) {
-            nsCOMPtr<nsITabChild> tabChild = ds->GetTabChild();
-            if (tabChild) {
+            nsCOMPtr<nsIBrowserChild> browserChild = ds->GetBrowserChild();
+            if (browserChild) {
               RefPtr<ContentFrameMessageManager> mm;
-              tabChild->GetMessageManager(getter_AddRefs(mm));
+              browserChild->GetMessageManager(getter_AddRefs(mm));
               if (mm) {
-                nsCOMPtr<nsISupports> tabChildAsSupports =
-                    do_QueryInterface(tabChild);
-                mozilla::TraceScriptHolder(tabChildAsSupports, aTrc);
+                nsCOMPtr<nsISupports> browserChildAsSupports =
+                    do_QueryInterface(browserChild);
+                mozilla::TraceScriptHolder(browserChildAsSupports, aTrc);
                 EventListenerManager* elm = mm->GetExistingListenerManager();
                 if (elm) {
                   elm->TraceListeners(aTrc);
                 }
                 // As of now there isn't an easy way to trace message listeners.
               }
             }
           }
--- a/dom/base/nsContentAreaDragDrop.cpp
+++ b/dom/base/nsContentAreaDragDrop.cpp
@@ -43,17 +43,17 @@
 #include "nsEscape.h"
 #include "nsContentUtils.h"
 #include "nsIMIMEService.h"
 #include "imgIContainer.h"
 #include "imgIRequest.h"
 #include "mozilla/dom/DataTransfer.h"
 #include "nsIMIMEInfo.h"
 #include "nsRange.h"
-#include "TabParent.h"
+#include "BrowserParent.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/HTMLAreaElement.h"
 #include "mozilla/dom/HTMLAnchorElement.h"
 #include "mozilla/dom/Selection.h"
 #include "nsVariant.h"
 #include "nsQueryObject.h"
 
 using namespace mozilla::dom;
@@ -547,20 +547,20 @@ nsresult DragDataProducer::Produce(DataT
       dsti && dsti->ItemType() == nsIDocShellTreeItem::typeChrome;
 
   // In chrome shells, only allow dragging inside editable areas.
   if (isChromeShell && !editingElement) {
     RefPtr<nsFrameLoaderOwner> flo = do_QueryObject(mTarget);
     if (flo) {
       RefPtr<nsFrameLoader> fl = flo->GetFrameLoader();
       if (fl) {
-        TabParent* tp = static_cast<TabParent*>(fl->GetRemoteBrowser());
+        BrowserParent* tp = static_cast<BrowserParent*>(fl->GetRemoteBrowser());
         if (tp) {
-          // We have a TabParent, so it may have data for dnd in case the child
-          // process started a dnd session.
+          // We have a BrowserParent, so it may have data for dnd in case the
+          // child process started a dnd session.
           tp->AddInitialDnDDataTo(aDataTransfer, aPrincipal);
         }
       }
     }
     return NS_OK;
   }
 
   if (isChromeShell && textControl) {
--- a/dom/base/nsContentPermissionHelper.cpp
+++ b/dom/base/nsContentPermissionHelper.cpp
@@ -11,18 +11,18 @@
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/PContentPermission.h"
 #include "mozilla/dom/Performance.h"
 #include "mozilla/dom/PermissionMessageUtils.h"
 #include "mozilla/dom/PContentPermissionRequestParent.h"
 #include "mozilla/dom/ScriptSettings.h"
-#include "mozilla/dom/TabChild.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Unused.h"
 #include "nsComponentManagerUtils.h"
 #include "nsArrayUtils.h"
 #include "nsIMutableArray.h"
 #include "nsContentPermissionHelper.h"
@@ -347,17 +347,17 @@ nsresult nsContentPermissionUtils::AskPe
 
   // for content process
   if (XRE_IsContentProcess()) {
     RefPtr<RemotePermissionRequest> req =
         new RemotePermissionRequest(aRequest, aWindow);
 
     MOZ_ASSERT(NS_IsMainThread());  // IPC can only be execute on main thread.
 
-    TabChild* child = TabChild::GetFrom(aWindow->GetDocShell());
+    BrowserChild* child = BrowserChild::GetFrom(aWindow->GetDocShell());
     NS_ENSURE_TRUE(child, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIArray> typeArray;
     nsresult rv = aRequest->GetTypes(getter_AddRefs(typeArray));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsTArray<PermissionRequest> permArray;
     ConvertArrayToPermissionRequest(typeArray, permArray);
--- a/dom/base/nsContentPolicy.cpp
+++ b/dom/base/nsContentPolicy.cpp
@@ -13,17 +13,17 @@
 #include "nsISupports.h"
 #include "nsXPCOM.h"
 #include "nsContentPolicyUtils.h"
 #include "mozilla/dom/nsCSPService.h"
 #include "nsContentPolicy.h"
 #include "nsIURI.h"
 #include "nsIDocShell.h"
 #include "nsIDOMWindow.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 #include "nsIContent.h"
 #include "nsIImageLoadingContent.h"
 #include "nsILoadContext.h"
 #include "nsCOMArray.h"
 #include "nsContentUtils.h"
 #include "mozilla/dom/nsMixedContentBlocker.h"
 #include "nsIContentSecurityPolicy.h"
 #include "mozilla/dom/TabGroup.h"
@@ -81,19 +81,20 @@ inline nsresult nsContentPolicy::CheckPo
   MOZ_ASSERT(decision, "Null out pointer");
   WARN_IF_URI_UNINITIALIZED(contentLocation, "Request URI");
   WARN_IF_URI_UNINITIALIZED(requestingLocation, "Requesting URI");
 
 #ifdef DEBUG
   {
     nsCOMPtr<nsINode> node(do_QueryInterface(requestingContext));
     nsCOMPtr<nsIDOMWindow> window(do_QueryInterface(requestingContext));
-    nsCOMPtr<nsITabChild> tabChild(do_QueryInterface(requestingContext));
-    NS_ASSERTION(!requestingContext || node || window || tabChild,
-                 "Context should be a DOM node, DOM window or a tabChild!");
+    nsCOMPtr<nsIBrowserChild> browserChild(
+        do_QueryInterface(requestingContext));
+    NS_ASSERTION(!requestingContext || node || window || browserChild,
+                 "Context should be a DOM node, DOM window or a browserChild!");
   }
 #endif
 
   /*
    * There might not be a requestinglocation. This can happen for
    * iframes with an image as src. Get the uri from the dom node.
    * See bug 254510
    */
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -69,17 +69,17 @@
 #include "mozilla/dom/IDTracker.h"
 #include "mozilla/dom/MouseEventBinding.h"
 #include "mozilla/dom/KeyboardEventBinding.h"
 #include "mozilla/dom/IPCBlobUtils.h"
 #include "mozilla/dom/NodeBinding.h"
 #include "mozilla/dom/Promise.h"
 #include "mozilla/dom/BrowserBridgeChild.h"
 #include "mozilla/dom/ScriptSettings.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/dom/Text.h"
 #include "mozilla/dom/TouchEvent.h"
 #include "mozilla/dom/ShadowRoot.h"
 #include "mozilla/dom/XULCommandEvent.h"
 #include "mozilla/dom/WorkerCommon.h"
 #include "mozilla/EventDispatcher.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/EventStateManager.h"
@@ -224,24 +224,24 @@
 #include "nsViewManager.h"
 #include "nsViewportInfo.h"
 #include "nsWidgetsCID.h"
 #include "nsIWindowProvider.h"
 #include "nsWrapperCacheInlines.h"
 #include "nsXULPopupManager.h"
 #include "xpcprivate.h"  // nsXPConnect
 #include "HTMLSplitOnSpacesTokenizer.h"
-#include "InProcessTabChildMessageManager.h"
+#include "InProcessBrowserChildMessageManager.h"
 #include "nsContentTypeParser.h"
 #include "nsICookiePermission.h"
 #include "nsICookieService.h"
 #include "ThirdPartyUtil.h"
 #include "mozilla/EnumSet.h"
 #include "mozilla/BloomFilter.h"
-#include "TabChild.h"
+#include "BrowserChild.h"
 #include "mozilla/dom/DocGroup.h"
 #include "mozilla/dom/TabGroup.h"
 #include "nsIWebNavigationInfo.h"
 #include "nsPluginHost.h"
 #include "nsIBrowser.h"
 #include "mozilla/HangAnnotations.h"
 #include "mozilla/Encoding.h"
 #include "nsXULElement.h"
@@ -7225,35 +7225,35 @@ nsresult nsContentUtils::GetHostOrIPv6Wi
   }
   CopyUTF8toUTF16(hostname, aHost);
   return NS_OK;
 }
 
 bool nsContentUtils::CallOnAllRemoteChildren(
     MessageBroadcaster* aManager, CallOnRemoteChildFunction aCallback,
     void* aArg) {
-  uint32_t tabChildCount = aManager->ChildCount();
-  for (uint32_t j = 0; j < tabChildCount; ++j) {
+  uint32_t browserChildCount = aManager->ChildCount();
+  for (uint32_t j = 0; j < browserChildCount; ++j) {
     RefPtr<MessageListenerManager> childMM = aManager->GetChildAt(j);
     if (!childMM) {
       continue;
     }
 
     RefPtr<MessageBroadcaster> nonLeafMM = MessageBroadcaster::From(childMM);
     if (nonLeafMM) {
       if (CallOnAllRemoteChildren(nonLeafMM, aCallback, aArg)) {
         return true;
       }
       continue;
     }
 
     mozilla::dom::ipc::MessageManagerCallback* cb = childMM->GetCallback();
     if (cb) {
       nsFrameLoader* fl = static_cast<nsFrameLoader*>(cb);
-      TabParent* remote = TabParent::GetFrom(fl);
+      BrowserParent* remote = BrowserParent::GetFrom(fl);
       if (remote && aCallback) {
         if (aCallback(remote, aArg)) {
           return true;
         }
       }
     }
   }
 
@@ -7277,17 +7277,17 @@ struct UIStateChangeInfo {
   UIStateChangeType mShowFocusRings;
 
   UIStateChangeInfo(UIStateChangeType aShowAccelerators,
                     UIStateChangeType aShowFocusRings)
       : mShowAccelerators(aShowAccelerators),
         mShowFocusRings(aShowFocusRings) {}
 };
 
-bool SetKeyboardIndicatorsChild(TabParent* aParent, void* aArg) {
+bool SetKeyboardIndicatorsChild(BrowserParent* aParent, void* aArg) {
   UIStateChangeInfo* stateInfo = static_cast<UIStateChangeInfo*>(aArg);
   Unused << aParent->SendSetKeyboardIndicators(stateInfo->mShowAccelerators,
                                                stateInfo->mShowFocusRings);
   return false;
 }
 
 void nsContentUtils::SetKeyboardIndicatorsOnRemoteChildren(
     nsPIDOMWindowOuter* aWindow, UIStateChangeType aShowAccelerators,
@@ -7297,17 +7297,17 @@ void nsContentUtils::SetKeyboardIndicato
                           (void*)&stateInfo);
 }
 
 nsresult nsContentUtils::IPCTransferableToTransferable(
     const IPCDataTransfer& aDataTransfer, const bool& aIsPrivateData,
     nsIPrincipal* aRequestingPrincipal,
     const nsContentPolicyType& aContentPolicyType,
     nsITransferable* aTransferable, mozilla::dom::ContentParent* aContentParent,
-    mozilla::dom::TabChild* aTabChild) {
+    mozilla::dom::BrowserChild* aBrowserChild) {
   nsresult rv;
 
   const nsTArray<IPCDataTransferItem>& items = aDataTransfer.items();
   for (const auto& item : items) {
     aTransferable->AddDataFlavor(item.flavor().get());
 
     if (item.data().type() == IPCDataTransferData::TnsString) {
       nsCOMPtr<nsISupportsString> dataWrapper =
@@ -7343,18 +7343,18 @@ nsresult nsContentUtils::IPCTransferable
 
         rv = aTransferable->SetTransferData(item.flavor().get(), dataWrapper);
 
         NS_ENSURE_SUCCESS(rv, rv);
       }
 
       if (aContentParent) {
         Unused << aContentParent->DeallocShmem(item.data().get_Shmem());
-      } else if (aTabChild) {
-        Unused << aTabChild->DeallocShmem(item.data().get_Shmem());
+      } else if (aBrowserChild) {
+        Unused << aBrowserChild->DeallocShmem(item.data().get_Shmem());
       }
     }
   }
 
   aTransferable->SetIsPrivateData(aIsPrivateData);
   aTransferable->SetRequestingPrincipal(aRequestingPrincipal);
   aTransferable->SetContentPolicyType(aContentPolicyType);
   return NS_OK;
@@ -9286,21 +9286,21 @@ void nsContentUtils::GetPresentationURL(
   }
 
   if (XRE_IsContentProcess()) {
     nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
     aDocShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
     nsCOMPtr<nsIDocShellTreeItem> root;
     aDocShell->GetRootTreeItem(getter_AddRefs(root));
     if (sameTypeRoot.get() == root.get()) {
-      // presentation URL is stored in TabChild for the top most
+      // presentation URL is stored in BrowserChild for the top most
       // <iframe mozbrowser> in content process.
-      TabChild* tabChild = TabChild::GetFrom(aDocShell);
-      if (tabChild) {
-        aPresentationUrl = tabChild->PresentationURL();
+      BrowserChild* browserChild = BrowserChild::GetFrom(aDocShell);
+      if (browserChild) {
+        aPresentationUrl = browserChild->PresentationURL();
       }
       return;
     }
   }
 
   nsCOMPtr<nsILoadContext> loadContext(do_QueryInterface(aDocShell));
   RefPtr<Element> topFrameElt;
   loadContext->GetTopFrameElement(getter_AddRefs(topFrameElt));
@@ -9828,23 +9828,24 @@ bool nsContentUtils::AttemptLargeAllocat
   rv = aChannel->GetRequestMethod(requestMethod);
   NS_ENSURE_SUCCESS(rv, false);
 
   if (NS_WARN_IF(!requestMethod.LowerCaseEqualsLiteral("get"))) {
     outer->SetLargeAllocStatus(LargeAllocStatus::NON_GET);
     return false;
   }
 
-  TabChild* tabChild = TabChild::GetFrom(outer);
-  NS_ENSURE_TRUE(tabChild, false);
-
-  if (tabChild->IsAwaitingLargeAlloc()) {
+  BrowserChild* browserChild = BrowserChild::GetFrom(outer);
+  NS_ENSURE_TRUE(browserChild, false);
+
+  if (browserChild->IsAwaitingLargeAlloc()) {
     NS_WARNING(
-        "In a Large-Allocation TabChild, ignoring Large-Allocation header!");
-    tabChild->StopAwaitingLargeAlloc();
+        "In a Large-Allocation BrowserChild, ignoring Large-Allocation "
+        "header!");
+    browserChild->StopAwaitingLargeAlloc();
     outer->SetLargeAllocStatus(LargeAllocStatus::SUCCESS);
     return false;
   }
 
   // On Win32 systems, we want to behave differently, so set the isWin32 bool to
   // be true iff we are on win32.
 #if defined(XP_WIN) && defined(_X86_)
   const bool isWin32 = true;
@@ -10555,29 +10556,29 @@ bool nsContentUtils::ContentIsLink(nsICo
   }
 
   return aContent->AsElement()->AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::type,
                                             nsGkAtoms::simple, eCaseMatters);
 }
 
 /* static */
 already_AddRefed<ContentFrameMessageManager>
-nsContentUtils::TryGetTabChildGlobal(nsISupports* aFrom) {
+nsContentUtils::TryGetBrowserChildGlobal(nsISupports* aFrom) {
   RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(aFrom);
   if (!frameLoaderOwner) {
     return nullptr;
   }
 
   RefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
   if (!frameLoader) {
     return nullptr;
   }
 
   RefPtr<ContentFrameMessageManager> manager =
-      frameLoader->GetTabChildMessageManager();
+      frameLoader->GetBrowserChildMessageManager();
   return manager.forget();
 }
 
 /* static */
 uint32_t nsContentUtils::InnerOrOuterWindowCreated() {
   MOZ_ASSERT(NS_IsMainThread());
   ++sInnerOrOuterWindowCount;
   return ++sInnerOrOuterWindowSerialCounter;
--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -142,19 +142,19 @@ class HTMLInputElement;
 class IPCDataTransfer;
 class IPCDataTransferItem;
 struct LifecycleCallbackArgs;
 struct LifecycleAdoptedCallbackArgs;
 class MessageBroadcaster;
 class NodeInfo;
 class ContentChild;
 class ContentParent;
-class TabChild;
+class BrowserChild;
 class Selection;
-class TabParent;
+class BrowserParent;
 }  // namespace dom
 
 namespace ipc {
 class Shmem;
 class IShmemAllocator;
 }  // namespace ipc
 
 namespace gfx {
@@ -197,18 +197,18 @@ struct EventNameMapping {
   int32_t mType;
   mozilla::EventMessage mMessage;
   mozilla::EventClassID mEventClassID;
   // True if mAtom is possibly used by special SVG/SMIL events, but
   // mMessage is eUnidentifiedEvent. See EventNameList.h
   bool mMaybeSpecialSVGorSMILEvent;
 };
 
-typedef bool (*CallOnRemoteChildFunction)(mozilla::dom::TabParent* aTabParent,
-                                          void* aArg);
+typedef bool (*CallOnRemoteChildFunction)(
+    mozilla::dom::BrowserParent* aBrowserParent, void* aArg);
 
 class nsContentUtils {
   friend class nsAutoScriptBlockerSuppressNodeRemoved;
   typedef mozilla::dom::Element Element;
   typedef mozilla::dom::Document Document;
   typedef mozilla::Cancelable Cancelable;
   typedef mozilla::CanBubble CanBubble;
   typedef mozilla::Composed Composed;
@@ -2800,18 +2800,18 @@ class nsContentUtils {
    * window. Return true from the callback to stop calling further children.
    */
   static void CallOnAllRemoteChildren(nsPIDOMWindowOuter* aWindow,
                                       CallOnRemoteChildFunction aCallback,
                                       void* aArg);
 
   /*
    * Call nsPIDOMWindow::SetKeyboardIndicators all all remote children. This is
-   * in here rather than nsGlobalWindow because TabParent indirectly includes
-   * Windows headers which aren't allowed there.
+   * in here rather than nsGlobalWindow because BrowserParent indirectly
+   * includes Windows headers which aren't allowed there.
    */
   static void SetKeyboardIndicatorsOnRemoteChildren(
       nsPIDOMWindowOuter* aWindow, UIStateChangeType aShowAccelerators,
       UIStateChangeType aShowFocusRings);
 
   /**
    * Given an nsIFile, attempts to read it into aString.
    *
@@ -2844,17 +2844,17 @@ class nsContentUtils {
   static bool IsFlavorImage(const nsACString& aFlavor);
 
   static nsresult IPCTransferableToTransferable(
       const mozilla::dom::IPCDataTransfer& aDataTransfer,
       const bool& aIsPrivateData, nsIPrincipal* aRequestingPrincipal,
       const nsContentPolicyType& aContentPolicyType,
       nsITransferable* aTransferable,
       mozilla::dom::ContentParent* aContentParent,
-      mozilla::dom::TabChild* aTabChild);
+      mozilla::dom::BrowserChild* aBrowserChild);
 
   static void TransferablesToIPCTransferables(
       nsIArray* aTransferables, nsTArray<mozilla::dom::IPCDataTransfer>& aIPC,
       bool aInSyncMessage, mozilla::dom::ContentChild* aChild,
       mozilla::dom::ContentParent* aParent);
 
   static void TransferableToIPCTransferable(
       nsITransferable* aTransferable,
@@ -3326,17 +3326,17 @@ class nsContentUtils {
    */
   static bool IsMessageInputEvent(const IPC::Message& aMsg);
 
   static void AsyncPrecreateStringBundles();
 
   static bool ContentIsLink(nsIContent* aContent);
 
   static already_AddRefed<mozilla::dom::ContentFrameMessageManager>
-  TryGetTabChildGlobal(nsISupports* aFrom);
+  TryGetBrowserChildGlobal(nsISupports* aFrom);
 
   // Get a serial number for a newly created inner or outer window.
   static uint32_t InnerOrOuterWindowCreated();
   // Record that an inner or outer window has been destroyed.
   static void InnerOrOuterWindowDestroyed();
   // Get the current number of inner or outer windows.
   static int32_t GetCurrentInnerOrOuterWindowCount() {
     return sInnerOrOuterWindowCount;
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -68,17 +68,17 @@
 #  include <gdk/gdkx.h>
 #endif
 
 #include "Layers.h"
 #include "gfxPrefs.h"
 
 #include "mozilla/dom/AudioDeviceInfo.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/IDBFactoryBinding.h"
 #include "mozilla/dom/IDBMutableFileBinding.h"
 #include "mozilla/dom/IDBMutableFile.h"
 #include "mozilla/dom/IndexedDatabaseManager.h"
 #include "mozilla/dom/PermissionMessageUtils.h"
 #include "mozilla/dom/Text.h"
 #include "mozilla/dom/quota/PersistenceType.h"
 #include "mozilla/dom/quota/QuotaManager.h"
--- a/dom/base/nsFocusManager.cpp
+++ b/dom/base/nsFocusManager.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 
 #include "nsFocusManager.h"
 
 #include "ChildIterator.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsGkAtoms.h"
 #include "nsGlobalWindow.h"
 #include "nsContentUtils.h"
@@ -33,17 +33,17 @@
 #include "nsXULPopupManager.h"
 #include "nsMenuPopupFrame.h"
 #include "nsIScriptObjectPrincipal.h"
 #include "nsIPrincipal.h"
 #include "nsIObserverService.h"
 #include "nsIObjectFrame.h"
 #include "nsBindingManager.h"
 #include "nsStyleCoord.h"
-#include "TabChild.h"
+#include "BrowserChild.h"
 #include "nsFrameLoader.h"
 #include "nsNumberControlFrame.h"
 #include "nsNetUtil.h"
 #include "nsRange.h"
 
 #include "mozilla/AccessibleCaretEventHub.h"
 #include "mozilla/ContentEvents.h"
 #include "mozilla/dom/Element.h"
@@ -832,18 +832,18 @@ nsFocusManager::WindowShown(mozIDOMWindo
       if (doc && doc->GetDocumentURI()) {
         LOGFOCUS((" Focused Window: %s",
                   doc->GetDocumentURI()->GetSpecOrDefault().get()));
       }
     }
   }
 
   if (nsIDocShell* docShell = window->GetDocShell()) {
-    if (nsCOMPtr<nsITabChild> child = docShell->GetTabChild()) {
-      bool active = static_cast<TabChild*>(child.get())->ParentIsActive();
+    if (nsCOMPtr<nsIBrowserChild> child = docShell->GetBrowserChild()) {
+      bool active = static_cast<BrowserChild*>(child.get())->ParentIsActive();
       ActivateOrDeactivate(window, active);
     }
   }
 
   if (mFocusedWindow != window) return NS_OK;
 
   if (aNeedsFocus) {
     nsCOMPtr<nsPIDOMWindowOuter> currentWindow;
@@ -1084,17 +1084,17 @@ void nsFocusManager::EnsureCurrentWidget
         nsCOMPtr<nsIWidget> widget;
         vm->GetRootWidget(getter_AddRefs(widget));
         if (widget) widget->SetFocus(false);
       }
     }
   }
 }
 
-bool ActivateOrDeactivateChild(TabParent* aParent, void* aArg) {
+bool ActivateOrDeactivateChild(BrowserParent* aParent, void* aArg) {
   bool active = static_cast<bool>(aArg);
   Unused << aParent->SendParentActivated(active);
   return false;
 }
 
 void nsFocusManager::ActivateOrDeactivate(nsPIDOMWindowOuter* aWindow,
                                           bool aActive) {
   if (!aWindow) {
@@ -1609,19 +1609,19 @@ bool nsFocusManager::Blur(nsPIDOMWindowO
     // plugin. But don't do this if we are blurring due to the window being
     // lowered, otherwise, the parent window can get raised again.
     if (mActiveWindow) {
       nsIFrame* contentFrame = element->GetPrimaryFrame();
       nsIObjectFrame* objectFrame = do_QueryFrame(contentFrame);
       if (aAdjustWidgets && objectFrame && !sTestMode) {
         if (XRE_IsContentProcess()) {
           // set focus to the top level window via the chrome process.
-          nsCOMPtr<nsITabChild> tabChild = docShell->GetTabChild();
-          if (tabChild) {
-            static_cast<TabChild*>(tabChild.get())
+          nsCOMPtr<nsIBrowserChild> browserChild = docShell->GetBrowserChild();
+          if (browserChild) {
+            static_cast<BrowserChild*>(browserChild.get())
                 ->SendDispatchFocusToTopLevelWindow();
           }
         } else {
           // note that the presshell's widget is being retrieved here, not the
           // one for the object frame.
           nsViewManager* vm = presShell->GetViewManager();
           if (vm) {
             nsCOMPtr<nsIWidget> widget;
@@ -1632,17 +1632,17 @@ bool nsFocusManager::Blur(nsPIDOMWindowO
             }
           }
         }
       }
     }
 
     // if the object being blurred is a remote browser, deactivate remote
     // content
-    if (TabParent* remote = TabParent::GetFrom(element)) {
+    if (BrowserParent* remote = BrowserParent::GetFrom(element)) {
       remote->Deactivate();
       LOGFOCUS(("Remote browser deactivated %p", remote));
     }
 
     // Same as above but for out-of-process iframes
     if (BrowserBridgeChild* bbc = BrowserBridgeChild::GetFrom(element)) {
       bbc->Deactivate();
       LOGFOCUS(("Out-of-process iframe deactivated %p", bbc));
@@ -1857,17 +1857,17 @@ void nsFocusManager::Focus(nsPIDOMWindow
       // that we might no longer be in the same document, due to the events we
       // fired above when aIsNewDocument.
       if (presShell->GetDocument() == aElement->GetComposedDoc()) {
         if (aAdjustWidgets && objectFrameWidget && !sTestMode)
           objectFrameWidget->SetFocus(false);
 
         // if the object being focused is a remote browser, activate remote
         // content
-        if (TabParent* remote = TabParent::GetFrom(aElement)) {
+        if (BrowserParent* remote = BrowserParent::GetFrom(aElement)) {
           remote->Activate();
           LOGFOCUS(("Remote browser activated %p", remote));
         }
 
         // Same as above but for out-of-process iframes
         if (BrowserBridgeChild* bbc = BrowserBridgeChild::GetFrom(aElement)) {
           bbc->Activate();
           LOGFOCUS(("Out-of-process iframe activated %p", bbc));
@@ -3487,17 +3487,17 @@ nsresult nsFocusManager::GetNextTabbable
             return NS_OK;
           }
 
           // If this is a remote child browser, call NavigateDocument to have
           // the child process continue the navigation. Return a special error
           // code to have the caller return early. If the child ends up not
           // being focusable in some way, the child process will call back
           // into document navigation again by calling MoveFocus.
-          TabParent* remote = TabParent::GetFrom(currentContent);
+          BrowserParent* remote = BrowserParent::GetFrom(currentContent);
           if (remote) {
             remote->NavigateByKey(aForward, aForDocumentNavigation);
             return NS_SUCCESS_DOM_NO_OPERATION;
           }
 
           // Same as above but for out-of-process iframes
           BrowserBridgeChild* bbc = BrowserBridgeChild::GetFrom(currentContent);
           if (bbc) {
--- a/dom/base/nsFocusManager.h
+++ b/dom/base/nsFocusManager.h
@@ -26,17 +26,17 @@ class nsIContent;
 class nsIDocShellTreeItem;
 class nsPIDOMWindowOuter;
 
 namespace mozilla {
 class PresShell;
 namespace dom {
 class Element;
 struct FocusOptions;
-class TabParent;
+class BrowserParent;
 }  // namespace dom
 }  // namespace mozilla
 
 struct nsDelayedBlurOrFocusEvent;
 
 /**
  * The focus manager keeps track of where the focus is, that is, the node
  * which receives key events.
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -60,23 +60,23 @@
 #include "nsNetUtil.h"
 
 #include "nsGkAtoms.h"
 #include "nsNameSpaceManager.h"
 
 #include "nsThreadUtils.h"
 
 #include "nsIDOMChromeWindow.h"
-#include "InProcessTabChildMessageManager.h"
+#include "InProcessBrowserChildMessageManager.h"
 
 #include "Layers.h"
 #include "ClientLayerManager.h"
 
 #include "ContentParent.h"
-#include "TabParent.h"
+#include "BrowserParent.h"
 #include "mozilla/AsyncEventDispatcher.h"
 #include "mozilla/BasePrincipal.h"
 #include "mozilla/GuardObjects.h"
 #include "mozilla/HTMLEditor.h"
 #include "mozilla/NullPrincipal.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/Unused.h"
@@ -148,34 +148,34 @@ typedef ScrollableLayerGuid::ViewID View
 // keep number of shells to a reasonable number on accidental recursion with a
 // small (but not 1) branching factor.  With large branching factors the number
 // of shells can rapidly become huge and run us out of memory.  To solve that,
 // we'd need to re-institute a fixed version of bug 98158.
 #define MAX_DEPTH_CONTENT_FRAMES 10
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsFrameLoader, mBrowsingContext,
                                       mMessageManager, mChildMessageManager,
-                                      mParentSHistory, mRemoteBrowser)
+                                      mParentSHistory, mBrowserParent)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFrameLoader)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFrameLoader)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFrameLoader)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY_CONCRETE(nsFrameLoader)
   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 nsFrameLoader::nsFrameLoader(Element* aOwner, BrowsingContext* aBrowsingContext,
                              bool aNetworkCreated)
     : mBrowsingContext(aBrowsingContext),
       mOwnerContent(aOwner),
       mDetachedSubdocFrame(nullptr),
       mPendingSwitchID(0),
-      mRemoteBrowser(nullptr),
+      mBrowserParent(nullptr),
       mChildID(0),
       mDepthTooGreat(false),
       mIsTopLevelContent(false),
       mDestroyCalled(false),
       mNeedsAsyncDestroy(false),
       mInSwap(false),
       mInShow(false),
       mHideCalled(false),
@@ -190,17 +190,17 @@ nsFrameLoader::nsFrameLoader(Element* aO
 }
 
 nsFrameLoader::nsFrameLoader(Element* aOwner, BrowsingContext* aBrowsingContext,
                              const mozilla::dom::RemotenessOptions& aOptions)
     : mBrowsingContext(aBrowsingContext),
       mOwnerContent(aOwner),
       mDetachedSubdocFrame(nullptr),
       mPendingSwitchID(0),
-      mRemoteBrowser(nullptr),
+      mBrowserParent(nullptr),
       mChildID(0),
       mDepthTooGreat(false),
       mIsTopLevelContent(false),
       mDestroyCalled(false),
       mNeedsAsyncDestroy(false),
       mInSwap(false),
       mInShow(false),
       mHideCalled(false),
@@ -540,37 +540,37 @@ nsresult nsFrameLoader::ReallyStartLoadi
 
 nsresult nsFrameLoader::ReallyStartLoadingInternal() {
   NS_ENSURE_STATE((mURIToLoad || mPendingSwitchID) && mOwnerContent &&
                   mOwnerContent->IsInComposedDoc());
 
   AUTO_PROFILER_LABEL("nsFrameLoader::ReallyStartLoadingInternal", OTHER);
 
   if (IsRemoteFrame()) {
-    if (!mRemoteBrowser && !mBrowserBridgeChild && !TryRemoteBrowser()) {
+    if (!mBrowserParent && !mBrowserBridgeChild && !TryRemoteBrowser()) {
       NS_WARNING("Couldn't create child process for iframe.");
       return NS_ERROR_FAILURE;
     }
 
     if (mPendingSwitchID) {
       if (mBrowserBridgeChild) {
         Unused << mBrowserBridgeChild->SendResumeLoad(mPendingSwitchID);
       } else {
-        mRemoteBrowser->ResumeLoad(mPendingSwitchID);
+        mBrowserParent->ResumeLoad(mPendingSwitchID);
       }
 
       mPendingSwitchID = 0;
     } else {
       if (mBrowserBridgeChild) {
         nsAutoCString spec;
         mURIToLoad->GetSpec(spec);
         Unused << mBrowserBridgeChild->SendLoadURL(spec);
       } else {
         // FIXME get error codes from child
-        mRemoteBrowser->LoadURL(mURIToLoad);
+        mBrowserParent->LoadURL(mURIToLoad);
       }
     }
 
     if (!mRemoteBrowserShown) {
       // This can fail if it's too early to show the frame, we will retry later.
       Unused << ShowRemoteFrame(ScreenIntSize(0, 0));
     }
 
@@ -1030,17 +1030,17 @@ void nsFrameLoader::MarginsChanged(uint3
 }
 
 bool nsFrameLoader::ShowRemoteFrame(const ScreenIntSize& size,
                                     nsSubDocumentFrame* aFrame) {
   AUTO_PROFILER_LABEL("nsFrameLoader::ShowRemoteFrame", OTHER);
   NS_ASSERTION(IsRemoteFrame(),
                "ShowRemote only makes sense on remote frames.");
 
-  if (!mRemoteBrowser && !mBrowserBridgeChild && !TryRemoteBrowser()) {
+  if (!mBrowserParent && !mBrowserBridgeChild && !TryRemoteBrowser()) {
     NS_ERROR("Couldn't create child process.");
     return false;
   }
 
   // FIXME/bug 589337: Show()/Hide() is pretty expensive for
   // cross-process layers; need to figure out what behavior we really
   // want here.  For now, hack.
   if (!mRemoteBrowserShown) {
@@ -1065,38 +1065,38 @@ bool nsFrameLoader::ShowRemoteFrame(cons
 
       Unused << mBrowserBridgeChild->SendShow(
           size, ParentWindowIsActive(mOwnerContent->OwnerDoc()), sizeMode);
       mRemoteBrowserShown = true;
       return true;
     }
 
     RenderFrame* rf =
-        mRemoteBrowser ? mRemoteBrowser->GetRenderFrame() : nullptr;
+        mBrowserParent ? mBrowserParent->GetRenderFrame() : nullptr;
 
     if (!rf || !rf->AttachLayerManager()) {
       // This is just not going to work.
       return false;
     }
 
-    mRemoteBrowser->Show(size, ParentWindowIsActive(mOwnerContent->OwnerDoc()));
+    mBrowserParent->Show(size, ParentWindowIsActive(mOwnerContent->OwnerDoc()));
     mRemoteBrowserShown = true;
 
     nsCOMPtr<nsIObserverService> os = services::GetObserverService();
     if (os) {
       os->NotifyObservers(ToSupports(this), "remote-browser-shown", nullptr);
     }
   } else {
     nsIntRect dimensions;
     NS_ENSURE_SUCCESS(GetWindowDimensions(dimensions), false);
 
     // Don't show remote iframe if we are waiting for the completion of reflow.
     if (!aFrame || !(aFrame->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
-      if (mRemoteBrowser) {
-        mRemoteBrowser->UpdateDimensions(dimensions, size);
+      if (mBrowserParent) {
+        mBrowserParent->UpdateDimensions(dimensions, size);
       } else if (mBrowserBridgeChild) {
         mBrowserBridgeChild->UpdateDimensions(dimensions, size);
       }
     }
   }
 
   return true;
 }
@@ -1187,39 +1187,39 @@ nsresult nsFrameLoader::SwapWithOtherRem
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   // FIXME: Consider supporting FrameLoader swapping for remote sub frames.
   if (mBrowserBridgeChild) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
-  if (!mRemoteBrowser || !aOther->mRemoteBrowser) {
+  if (!mBrowserParent || !aOther->mBrowserParent) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
-  if (mRemoteBrowser->IsIsolatedMozBrowserElement() !=
-      aOther->mRemoteBrowser->IsIsolatedMozBrowserElement()) {
+  if (mBrowserParent->IsIsolatedMozBrowserElement() !=
+      aOther->mBrowserParent->IsIsolatedMozBrowserElement()) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   // When we swap docShells, maybe we have to deal with a new page created just
   // for this operation. In this case, the browser code should already have set
   // the correct userContextId attribute value in the owning element, but our
   // docShell, that has been created way before) doesn't know that that
   // happened.
   // This is the reason why now we must retrieve the correct value from the
   // usercontextid attribute before comparing our originAttributes with the
   // other one.
-  OriginAttributes ourOriginAttributes = mRemoteBrowser->OriginAttributesRef();
+  OriginAttributes ourOriginAttributes = mBrowserParent->OriginAttributesRef();
   rv = PopulateUserContextIdFromAttribute(ourOriginAttributes);
   NS_ENSURE_SUCCESS(rv, rv);
 
   OriginAttributes otherOriginAttributes =
-      aOther->mRemoteBrowser->OriginAttributesRef();
+      aOther->mBrowserParent->OriginAttributesRef();
   rv = aOther->PopulateUserContextIdFromAttribute(otherOriginAttributes);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (ourOriginAttributes != otherOriginAttributes) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   bool ourHasHistory =
@@ -1253,66 +1253,66 @@ nsresult nsFrameLoader::SwapWithOtherRem
 
   rv = ourFrameFrame->BeginSwapDocShells(otherFrame);
   if (NS_FAILED(rv)) {
     mInSwap = aOther->mInSwap = false;
     return rv;
   }
 
   nsCOMPtr<nsIBrowserDOMWindow> otherBrowserDOMWindow =
-      aOther->mRemoteBrowser->GetBrowserDOMWindow();
+      aOther->mBrowserParent->GetBrowserDOMWindow();
   nsCOMPtr<nsIBrowserDOMWindow> browserDOMWindow =
-      mRemoteBrowser->GetBrowserDOMWindow();
+      mBrowserParent->GetBrowserDOMWindow();
 
   if (!!otherBrowserDOMWindow != !!browserDOMWindow) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
 
   // Destroy browser frame scripts for content leaving a frame with browser API
   if (OwnerIsMozBrowserFrame() && !aOther->OwnerIsMozBrowserFrame()) {
     DestroyBrowserFrameScripts();
   }
   if (!OwnerIsMozBrowserFrame() && aOther->OwnerIsMozBrowserFrame()) {
     aOther->DestroyBrowserFrameScripts();
   }
 
-  aOther->mRemoteBrowser->SetBrowserDOMWindow(browserDOMWindow);
-  mRemoteBrowser->SetBrowserDOMWindow(otherBrowserDOMWindow);
+  aOther->mBrowserParent->SetBrowserDOMWindow(browserDOMWindow);
+  mBrowserParent->SetBrowserDOMWindow(otherBrowserDOMWindow);
 
 #ifdef XP_WIN
   // Native plugin windows used by this remote content need to be reparented.
   if (nsPIDOMWindowOuter* newWin = ourDoc->GetWindow()) {
     RefPtr<nsIWidget> newParent =
         nsGlobalWindowOuter::Cast(newWin)->GetMainWidget();
     const ManagedContainer<mozilla::plugins::PPluginWidgetParent>& plugins =
-        aOther->mRemoteBrowser->ManagedPPluginWidgetParent();
+        aOther->mBrowserParent->ManagedPPluginWidgetParent();
     for (auto iter = plugins.ConstIter(); !iter.Done(); iter.Next()) {
       static_cast<mozilla::plugins::PluginWidgetParent*>(iter.Get()->GetKey())
           ->SetParent(newParent);
     }
   }
 #endif  // XP_WIN
 
-  MaybeUpdatePrimaryTabParent(eTabParentRemoved);
-  aOther->MaybeUpdatePrimaryTabParent(eTabParentRemoved);
+  MaybeUpdatePrimaryBrowserParent(eBrowserParentRemoved);
+  aOther->MaybeUpdatePrimaryBrowserParent(eBrowserParentRemoved);
 
   SetOwnerContent(otherContent);
   aOther->SetOwnerContent(ourContent);
 
-  mRemoteBrowser->SetOwnerElement(otherContent);
-  aOther->mRemoteBrowser->SetOwnerElement(ourContent);
+  mBrowserParent->SetOwnerElement(otherContent);
+  aOther->mBrowserParent->SetOwnerElement(ourContent);
 
   // Update window activation state for the swapped owner content.
-  Unused << mRemoteBrowser->SendParentActivated(
+  Unused << mBrowserParent->SendParentActivated(
       ParentWindowIsActive(otherContent->OwnerDoc()));
-  Unused << aOther->mRemoteBrowser->SendParentActivated(
+  Unused << aOther->mBrowserParent->SendParentActivated(
       ParentWindowIsActive(ourContent->OwnerDoc()));
 
-  MaybeUpdatePrimaryTabParent(eTabParentChanged);
-  aOther->MaybeUpdatePrimaryTabParent(eTabParentChanged);
+  MaybeUpdatePrimaryBrowserParent(eBrowserParentChanged);
+  aOther->MaybeUpdatePrimaryBrowserParent(eBrowserParentChanged);
 
   RefPtr<nsFrameMessageManager> ourMessageManager = mMessageManager;
   RefPtr<nsFrameMessageManager> otherMessageManager = aOther->mMessageManager;
   // Swap and setup things in parent message managers.
   if (ourMessageManager) {
     ourMessageManager->SetCallback(aOther);
   }
   if (otherMessageManager) {
@@ -1345,19 +1345,19 @@ nsresult nsFrameLoader::SwapWithOtherRem
     return rv;
   }
   MutableTabContext otherContext;
   rv = aOther->GetNewTabContext(&otherContext);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  Unused << mRemoteBrowser->SendSwappedWithOtherRemoteLoader(
+  Unused << mBrowserParent->SendSwappedWithOtherRemoteLoader(
       ourContext.AsIPCTabContext());
-  Unused << aOther->mRemoteBrowser->SendSwappedWithOtherRemoteLoader(
+  Unused << aOther->mBrowserParent->SendSwappedWithOtherRemoteLoader(
       otherContext.AsIPCTabContext());
   return NS_OK;
 }
 
 class MOZ_RAII AutoResetInFrameSwap final {
  public:
   AutoResetInFrameSwap(
       nsFrameLoader* aThisFrameLoader, nsFrameLoader* aOtherFrameLoader,
@@ -1702,25 +1702,25 @@ nsresult nsFrameLoader::SwapWithOtherLoa
 
   ourWindow->SetFrameElementInternal(otherFrameElement);
   otherWindow->SetFrameElementInternal(ourFrameElement);
 
   RefPtr<nsFrameMessageManager> ourMessageManager = mMessageManager;
   RefPtr<nsFrameMessageManager> otherMessageManager = aOther->mMessageManager;
   // Swap pointers in child message managers.
   if (mChildMessageManager) {
-    InProcessTabChildMessageManager* tabChild = mChildMessageManager;
-    tabChild->SetOwner(otherContent);
-    tabChild->SetChromeMessageManager(otherMessageManager);
+    InProcessBrowserChildMessageManager* browserChild = mChildMessageManager;
+    browserChild->SetOwner(otherContent);
+    browserChild->SetChromeMessageManager(otherMessageManager);
   }
   if (aOther->mChildMessageManager) {
-    InProcessTabChildMessageManager* otherTabChild =
+    InProcessBrowserChildMessageManager* otherBrowserChild =
         aOther->mChildMessageManager;
-    otherTabChild->SetOwner(ourContent);
-    otherTabChild->SetChromeMessageManager(ourMessageManager);
+    otherBrowserChild->SetOwner(ourContent);
+    otherBrowserChild->SetChromeMessageManager(ourMessageManager);
   }
   // Swap and setup things in parent message managers.
   if (mMessageManager) {
     mMessageManager->SetCallback(aOther);
   }
   if (aOther->mMessageManager) {
     aOther->mMessageManager->SetCallback(this);
   }
@@ -1798,39 +1798,39 @@ void nsFrameLoader::StartDestroy() {
   // the message manager on the frame.
   if (mMessageManager) {
     mMessageManager->Close();
   }
 
   // Retain references to the <browser> element and the frameloader in case we
   // receive any messages from the message manager on the frame. These
   // references are dropped in DestroyComplete.
-  if (mChildMessageManager || mRemoteBrowser) {
+  if (mChildMessageManager || mBrowserParent) {
     mOwnerContentStrong = mOwnerContent;
-    if (mRemoteBrowser) {
-      mRemoteBrowser->CacheFrameLoader(this);
+    if (mBrowserParent) {
+      mBrowserParent->CacheFrameLoader(this);
     }
     if (mChildMessageManager) {
       mChildMessageManager->CacheFrameLoader(this);
     }
   }
 
-  // If the TabParent has installed any event listeners on the window, this is
-  // its last chance to remove them while we're still in the document.
-  if (mRemoteBrowser) {
-    mRemoteBrowser->RemoveWindowListeners();
+  // If the BrowserParent has installed any event listeners on the window, this
+  // is its last chance to remove them while we're still in the document.
+  if (mBrowserParent) {
+    mBrowserParent->RemoveWindowListeners();
   }
 
   nsCOMPtr<Document> doc;
   bool dynamicSubframeRemoval = false;
   if (mOwnerContent) {
     doc = mOwnerContent->OwnerDoc();
     dynamicSubframeRemoval = !mIsTopLevelContent && !doc->InUnlinkOrDeletion();
     doc->SetSubDocumentFor(mOwnerContent, nullptr);
-    MaybeUpdatePrimaryTabParent(eTabParentRemoved);
+    MaybeUpdatePrimaryBrowserParent(eBrowserParentRemoved);
     SetOwnerContent(nullptr);
   }
 
   // Seems like this is a dynamic frame removal.
   if (dynamicSubframeRemoval) {
     if (GetDocShell()) {
       GetDocShell()->RemoveFromSessionHistory();
     }
@@ -1864,17 +1864,17 @@ void nsFrameLoader::StartDestroy() {
   }
 }
 
 nsresult nsFrameLoaderDestroyRunnable::Run() {
   switch (mPhase) {
     case eDestroyDocShell:
       mFrameLoader->DestroyDocShell();
 
-      // In the out-of-process case, TabParent will eventually call
+      // In the out-of-process case, BrowserParent will eventually call
       // DestroyComplete once it receives a __delete__ message from the child.
       // In the in-process case, we dispatch a series of runnables to ensure
       // that DestroyComplete gets called at the right time. The frame loader is
       // kept alive by mFrameLoader during this time.
       if (mFrameLoader->mChildMessageManager) {
         // When the docshell is destroyed, NotifyWindowIDDestroyed is called to
         // asynchronously notify {outer,inner}-window-destroyed via a runnable.
         // We don't want DestroyComplete to run until after those runnables have
@@ -1907,21 +1907,21 @@ nsresult nsFrameLoaderDestroyRunnable::R
   return NS_OK;
 }
 
 void nsFrameLoader::DestroyDocShell() {
   // This code runs after the frameloader has been detached from the <browser>
   // element. We postpone this work because we may not be allowed to run
   // script at that time.
 
-  // Ask the TabChild to fire the frame script "unload" event, destroy its
+  // Ask the BrowserChild to fire the frame script "unload" event, destroy its
   // docshell, and finally destroy the PBrowser actor. This eventually leads to
   // nsFrameLoader::DestroyComplete being called.
-  if (mRemoteBrowser) {
-    mRemoteBrowser->Destroy();
+  if (mBrowserParent) {
+    mBrowserParent->Destroy();
   }
 
   if (mBrowserBridgeChild) {
     Unused << mBrowserBridgeChild->Send__delete__(mBrowserBridgeChild);
     mBrowserBridgeChild = nullptr;
   }
 
   // Fire the "unload" event if we're in-process.
@@ -1944,31 +1944,31 @@ void nsFrameLoader::DestroyDocShell() {
 
 void nsFrameLoader::DestroyComplete() {
   // We get here, as part of StartDestroy, after the docshell has been destroyed
   // and all message manager messages sent during docshell destruction have been
   // dispatched.  We also get here if the child process crashes. In the latter
   // case, StartDestroy might not have been called.
 
   // Drop the strong references created in StartDestroy.
-  if (mChildMessageManager || mRemoteBrowser) {
+  if (mChildMessageManager || mBrowserParent) {
     mOwnerContentStrong = nullptr;
-    if (mRemoteBrowser) {
-      mRemoteBrowser->CacheFrameLoader(nullptr);
+    if (mBrowserParent) {
+      mBrowserParent->CacheFrameLoader(nullptr);
     }
     if (mChildMessageManager) {
       mChildMessageManager->CacheFrameLoader(nullptr);
     }
   }
 
-  // Call TabParent::Destroy if we haven't already (in case of a crash).
-  if (mRemoteBrowser) {
-    mRemoteBrowser->SetOwnerElement(nullptr);
-    mRemoteBrowser->Destroy();
-    mRemoteBrowser = nullptr;
+  // Call BrowserParent::Destroy if we haven't already (in case of a crash).
+  if (mBrowserParent) {
+    mBrowserParent->SetOwnerElement(nullptr);
+    mBrowserParent->Destroy();
+    mBrowserParent = nullptr;
   }
 
   if (mBrowserBridgeChild) {
     Unused << mBrowserBridgeChild->Send__delete__(mBrowserBridgeChild);
     mBrowserBridgeChild = nullptr;
   }
 
   if (mMessageManager) {
@@ -2490,28 +2490,28 @@ nsresult nsFrameLoader::GetWindowDimensi
   nsCOMPtr<nsIBaseWindow> treeOwnerAsWin(do_GetInterface(parentOwner));
   treeOwnerAsWin->GetPosition(&aRect.x, &aRect.y);
   treeOwnerAsWin->GetSize(&aRect.width, &aRect.height);
   return NS_OK;
 }
 
 nsresult nsFrameLoader::UpdatePositionAndSize(nsSubDocumentFrame* aIFrame) {
   if (IsRemoteFrame()) {
-    if (mRemoteBrowser || mBrowserBridgeChild) {
+    if (mBrowserParent || mBrowserBridgeChild) {
       ScreenIntSize size = aIFrame->GetSubdocumentSize();
       // If we were not able to show remote frame before, we should probably
       // retry now to send correct showInfo.
       if (!mRemoteBrowserShown) {
         ShowRemoteFrame(size, aIFrame);
       }
       nsIntRect dimensions;
       NS_ENSURE_SUCCESS(GetWindowDimensions(dimensions), NS_ERROR_FAILURE);
       mLazySize = size;
-      if (mRemoteBrowser) {
-        mRemoteBrowser->UpdateDimensions(dimensions, size);
+      if (mBrowserParent) {
+        mBrowserParent->UpdateDimensions(dimensions, size);
       } else if (mBrowserBridgeChild) {
         mBrowserBridgeChild->UpdateDimensions(dimensions, size);
       }
     }
     return NS_OK;
   }
   UpdateBaseWindowPositionAndSize(aIFrame);
   return NS_OK;
@@ -2560,40 +2560,41 @@ uint32_t nsFrameLoader::LazyHeight() con
   nsIFrame* frame = GetPrimaryFrameOfOwningContent();
   if (frame) {
     lazyHeight = frame->PresContext()->DevPixelsToIntCSSPixels(lazyHeight);
   }
 
   return lazyHeight;
 }
 
-static Tuple<ContentParent*, TabParent*> GetContentParent(Element* aBrowser) {
-  using ReturnTuple = Tuple<ContentParent*, TabParent*>;
+static Tuple<ContentParent*, BrowserParent*> GetContentParent(
+    Element* aBrowser) {
+  using ReturnTuple = Tuple<ContentParent*, BrowserParent*>;
 
   nsCOMPtr<nsIBrowser> browser = aBrowser ? aBrowser->AsBrowser() : nullptr;
   if (!browser) {
     return ReturnTuple(nullptr, nullptr);
   }
 
   RefPtr<nsFrameLoader> otherLoader;
   browser->GetSameProcessAsFrameLoader(getter_AddRefs(otherLoader));
   if (!otherLoader) {
     return ReturnTuple(nullptr, nullptr);
   }
 
-  TabParent* tabParent = TabParent::GetFrom(otherLoader);
-  if (tabParent && tabParent->Manager()) {
-    return MakeTuple(tabParent->Manager(), tabParent);
+  BrowserParent* browserParent = BrowserParent::GetFrom(otherLoader);
+  if (browserParent && browserParent->Manager()) {
+    return MakeTuple(browserParent->Manager(), browserParent);
   }
 
   return ReturnTuple(nullptr, nullptr);
 }
 
 bool nsFrameLoader::TryRemoteBrowser() {
-  NS_ASSERTION(!mRemoteBrowser && !mBrowserBridgeChild,
+  NS_ASSERTION(!mBrowserParent && !mBrowserBridgeChild,
                "TryRemoteBrowser called with a remote browser already?");
 
   if (!mOwnerContent) {
     return false;
   }
 
   // XXXsmaug Per spec (2014/08/21) frameloader should not work in case the
   //         element isn't in document, only in shadow dom, but that will change
@@ -2616,19 +2617,20 @@ bool nsFrameLoader::TryRemoteBrowser() {
     return false;
   }
 
   nsCOMPtr<nsIDocShell> parentDocShell = parentWin->GetDocShell();
   if (!parentDocShell) {
     return false;
   }
 
-  TabParent* openingTab = TabParent::GetFrom(parentDocShell->GetOpener());
+  BrowserParent* openingTab =
+      BrowserParent::GetFrom(parentDocShell->GetOpener());
   RefPtr<ContentParent> openerContentParent;
-  RefPtr<TabParent> sameTabGroupAs;
+  RefPtr<BrowserParent> sameTabGroupAs;
 
   if (openingTab && openingTab->Manager()) {
     openerContentParent = openingTab->Manager();
   }
 
   // <iframe mozbrowser> gets to skip these checks.
   // iframes for JS plugins also get to skip these checks. We control the URL
   // that gets loaded, but the load is triggered from the document containing
@@ -2683,93 +2685,93 @@ bool nsFrameLoader::TryRemoteBrowser() {
   }
 
   AUTO_PROFILER_LABEL("nsFrameLoader::TryRemoteBrowser:Create", OTHER);
 
   MutableTabContext context;
   nsresult rv = GetNewTabContext(&context);
   NS_ENSURE_SUCCESS(rv, false);
 
-  uint64_t nextTabParentId = 0;
+  uint64_t nextRemoteTabId = 0;
   if (mOwnerContent) {
-    nsAutoString nextTabParentIdAttr;
-    mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::nextTabParentId,
-                           nextTabParentIdAttr);
-    nextTabParentId =
-        strtoull(NS_ConvertUTF16toUTF8(nextTabParentIdAttr).get(), nullptr, 10);
+    nsAutoString nextBrowserParentIdAttr;
+    mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::nextRemoteTabId,
+                           nextBrowserParentIdAttr);
+    nextRemoteTabId = strtoull(
+        NS_ConvertUTF16toUTF8(nextBrowserParentIdAttr).get(), nullptr, 10);
 
     // We may be in a window that was just opened, so try the
     // nsIBrowserDOMWindow API as a backup.
-    if (!nextTabParentId && window) {
-      Unused << window->GetNextTabParentId(&nextTabParentId);
+    if (!nextRemoteTabId && window) {
+      Unused << window->GetNextRemoteTabId(&nextRemoteTabId);
     }
   }
 
   nsCOMPtr<Element> ownerElement = mOwnerContent;
 
   // If we're in a content process, create a BrowserBridgeChild actor.
   if (XRE_IsContentProcess()) {
     mBrowsingContext->SetEmbedderElement(mOwnerContent);
 
     mBrowserBridgeChild = BrowserBridgeChild::Create(
         this, context, NS_LITERAL_STRING(DEFAULT_REMOTE_TYPE),
         mBrowsingContext);
     return !!mBrowserBridgeChild;
   }
 
-  mRemoteBrowser = ContentParent::CreateBrowser(
+  mBrowserParent = ContentParent::CreateBrowser(
       context, ownerElement, mBrowsingContext, openerContentParent,
-      sameTabGroupAs, nextTabParentId);
-  if (!mRemoteBrowser) {
+      sameTabGroupAs, nextRemoteTabId);
+  if (!mBrowserParent) {
     return false;
   }
 
   // We no longer need the remoteType attribute on the frame element.
   // The remoteType can be queried by asking the message manager instead.
   ownerElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::RemoteType, false);
 
-  // Now that mRemoteBrowser is set, we can initialize the RenderFrame
-  mRemoteBrowser->InitRendering();
-
-  MaybeUpdatePrimaryTabParent(eTabParentChanged);
-
-  mChildID = mRemoteBrowser->Manager()->ChildID();
+  // Now that mBrowserParent is set, we can initialize the RenderFrame
+  mBrowserParent->InitRendering();
+
+  MaybeUpdatePrimaryBrowserParent(eBrowserParentChanged);
+
+  mChildID = mBrowserParent->Manager()->ChildID();
 
   nsCOMPtr<nsIDocShellTreeItem> rootItem;
   parentDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
   nsCOMPtr<nsPIDOMWindowOuter> rootWin = rootItem->GetWindow();
   nsCOMPtr<nsIDOMChromeWindow> rootChromeWin = do_QueryInterface(rootWin);
 
   if (rootChromeWin) {
     nsCOMPtr<nsIBrowserDOMWindow> browserDOMWin;
     rootChromeWin->GetBrowserDOMWindow(getter_AddRefs(browserDOMWin));
-    mRemoteBrowser->SetBrowserDOMWindow(browserDOMWin);
+    mBrowserParent->SetBrowserDOMWindow(browserDOMWin);
   }
 
   // Set up a parent SHistory
   if (XRE_IsParentProcess()) {
     // XXX(nika): Once we get out of process iframes we won't want to
     // unconditionally set this up. What do we do for iframes in a chrome loaded
     // document for example?
     mParentSHistory = new ParentSHistory(this);
   }
 
   // For xul:browsers, update some settings based on attributes:
   if (mOwnerContent->IsXULElement()) {
-    // Send down the name of the browser through mRemoteBrowser if it is set.
+    // Send down the name of the browser through mBrowserParent if it is set.
     nsAutoString frameName;
     mOwnerContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, frameName);
     if (nsContentUtils::IsOverridingWindowName(frameName)) {
-      Unused << mRemoteBrowser->SendSetWindowName(frameName);
+      Unused << mBrowserParent->SendSetWindowName(frameName);
     }
     // Allow scripts to close the window if the browser specified so:
     if (mOwnerContent->AttrValueIs(kNameSpaceID_None,
                                    nsGkAtoms::allowscriptstoclose,
                                    nsGkAtoms::_true, eCaseMatters)) {
-      Unused << mRemoteBrowser->SendAllowScriptsToClose();
+      Unused << mBrowserParent->SendAllowScriptsToClose();
     }
   }
 
   ReallyLoadFrameScripts();
   InitializeBrowserAPI();
 
   return true;
 }
@@ -2778,75 +2780,75 @@ bool nsFrameLoader::IsRemoteFrame() {
   if (mIsRemoteFrame) {
     MOZ_ASSERT(!GetDocShell(), "Found a remote frame with a DocShell");
     return true;
   }
   return false;
 }
 
 mozilla::dom::PBrowserParent* nsFrameLoader::GetRemoteBrowser() const {
-  return mRemoteBrowser;
+  return mBrowserParent;
 }
 
 mozilla::dom::BrowserBridgeChild* nsFrameLoader::GetBrowserBridgeChild() const {
   return mBrowserBridgeChild;
 }
 
 mozilla::layers::LayersId nsFrameLoader::GetLayersId() const {
   MOZ_ASSERT(mIsRemoteFrame);
-  if (mRemoteBrowser) {
-    return mRemoteBrowser->GetRenderFrame()->GetLayersId();
+  if (mBrowserParent) {
+    return mBrowserParent->GetRenderFrame()->GetLayersId();
   }
   if (mBrowserBridgeChild) {
     return mBrowserBridgeChild->GetLayersId();
   }
   return mozilla::layers::LayersId{};
 }
 
 void nsFrameLoader::ActivateRemoteFrame(ErrorResult& aRv) {
-  if (!mRemoteBrowser) {
+  if (!mBrowserParent) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return;
   }
 
-  mRemoteBrowser->Activate();
+  mBrowserParent->Activate();
 }
 
 void nsFrameLoader::DeactivateRemoteFrame(ErrorResult& aRv) {
-  if (!mRemoteBrowser) {
+  if (!mBrowserParent) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return;
   }
 
-  mRemoteBrowser->Deactivate();
+  mBrowserParent->Deactivate();
 }
 
 void nsFrameLoader::SendCrossProcessMouseEvent(const nsAString& aType, float aX,
                                                float aY, int32_t aButton,
                                                int32_t aClickCount,
                                                int32_t aModifiers,
                                                bool aIgnoreRootScrollFrame,
                                                ErrorResult& aRv) {
-  if (!mRemoteBrowser) {
+  if (!mBrowserParent) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
-  mRemoteBrowser->SendMouseEvent(aType, aX, aY, aButton, aClickCount,
+  mBrowserParent->SendMouseEvent(aType, aX, aY, aButton, aClickCount,
                                  aModifiers, aIgnoreRootScrollFrame);
 }
 
 void nsFrameLoader::ActivateFrameEvent(const nsAString& aType, bool aCapture,
                                        ErrorResult& aRv) {
-  if (!mRemoteBrowser) {
+  if (!mBrowserParent) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
-  bool ok = mRemoteBrowser->SendActivateFrameEvent(nsString(aType), aCapture);
+  bool ok = mBrowserParent->SendActivateFrameEvent(nsString(aType), aCapture);
   if (!ok) {
     aRv.Throw(NS_ERROR_NOT_AVAILABLE);
   }
 }
 
 nsresult nsFrameLoader::CreateStaticClone(nsFrameLoader* aDest) {
   aDest->MaybeCreateDocShell();
   NS_ENSURE_STATE(aDest->GetDocShell());
@@ -2867,75 +2869,76 @@ nsresult nsFrameLoader::CreateStaticClon
   nsCOMPtr<Document> clonedDoc = doc->CreateStaticClone(aDest->GetDocShell());
 
   viewer->SetDocument(clonedDoc);
   return NS_OK;
 }
 
 bool nsFrameLoader::DoLoadMessageManagerScript(const nsAString& aURL,
                                                bool aRunInGlobalScope) {
-  auto* tabParent = TabParent::GetFrom(GetRemoteBrowser());
-  if (tabParent) {
-    return tabParent->SendLoadRemoteScript(nsString(aURL), aRunInGlobalScope);
+  auto* browserParent = BrowserParent::GetFrom(GetRemoteBrowser());
+  if (browserParent) {
+    return browserParent->SendLoadRemoteScript(nsString(aURL),
+                                               aRunInGlobalScope);
   }
-  RefPtr<InProcessTabChildMessageManager> tabChild =
-      GetTabChildMessageManager();
-  if (tabChild) {
-    tabChild->LoadFrameScript(aURL, aRunInGlobalScope);
+  RefPtr<InProcessBrowserChildMessageManager> browserChild =
+      GetBrowserChildMessageManager();
+  if (browserChild) {
+    browserChild->LoadFrameScript(aURL, aRunInGlobalScope);
   }
   return true;
 }
 
 class nsAsyncMessageToChild : public nsSameProcessAsyncMessageBase,
                               public Runnable {
  public:
   nsAsyncMessageToChild(JS::RootingContext* aRootingCx,
                         JS::Handle<JSObject*> aCpows,
                         nsFrameLoader* aFrameLoader)
       : nsSameProcessAsyncMessageBase(aRootingCx, aCpows),
         mozilla::Runnable("nsAsyncMessageToChild"),
         mFrameLoader(aFrameLoader) {}
 
   NS_IMETHOD Run() override {
-    InProcessTabChildMessageManager* tabChild =
+    InProcessBrowserChildMessageManager* browserChild =
         mFrameLoader->mChildMessageManager;
     // Since bug 1126089, messages can arrive even when the docShell is
     // destroyed. Here we make sure that those messages are not delivered.
-    if (tabChild && tabChild->GetInnerManager() &&
+    if (browserChild && browserChild->GetInnerManager() &&
         mFrameLoader->GetExistingDocShell()) {
       JS::Rooted<JSObject*> kungFuDeathGrip(dom::RootingCx(),
-                                            tabChild->GetWrapper());
-      ReceiveMessage(static_cast<EventTarget*>(tabChild), mFrameLoader,
-                     tabChild->GetInnerManager());
+                                            browserChild->GetWrapper());
+      ReceiveMessage(static_cast<EventTarget*>(browserChild), mFrameLoader,
+                     browserChild->GetInnerManager());
     }
     return NS_OK;
   }
   RefPtr<nsFrameLoader> mFrameLoader;
 };
 
 nsresult nsFrameLoader::DoSendAsyncMessage(JSContext* aCx,
                                            const nsAString& aMessage,
                                            StructuredCloneData& aData,
                                            JS::Handle<JSObject*> aCpows,
                                            nsIPrincipal* aPrincipal) {
-  TabParent* tabParent = mRemoteBrowser;
-  if (tabParent) {
+  BrowserParent* browserParent = mBrowserParent;
+  if (browserParent) {
     ClonedMessageData data;
-    ContentParent* cp = tabParent->Manager();
+    ContentParent* cp = browserParent->Manager();
     if (!BuildClonedMessageDataForParent(cp, aData, data)) {
       MOZ_CRASH();
       return NS_ERROR_DOM_DATA_CLONE_ERR;
     }
     InfallibleTArray<mozilla::jsipc::CpowEntry> cpows;
     jsipc::CPOWManager* mgr = cp->GetCPOWManager();
     if (aCpows && (!mgr || !mgr->Wrap(aCx, aCpows, &cpows))) {
       return NS_ERROR_UNEXPECTED;
     }
-    if (tabParent->SendAsyncMessage(nsString(aMessage), cpows,
-                                    IPC::Principal(aPrincipal), data)) {
+    if (browserParent->SendAsyncMessage(nsString(aMessage), cpows,
+                                        IPC::Principal(aPrincipal), data)) {
       return NS_OK;
     } else {
       return NS_ERROR_UNEXPECTED;
     }
   }
 
   if (mChildMessageManager) {
     JS::RootingContext* rcx = JS::RootingContext::get(aCx);
@@ -3002,17 +3005,17 @@ nsresult nsFrameLoader::EnsureMessageMan
     if (NS_FAILED(rv)) {
       return rv;
     }
     MOZ_ASSERT(GetDocShell(),
                "MaybeCreateDocShell succeeded, but null docShell");
     if (!GetDocShell()) {
       return NS_ERROR_FAILURE;
     }
-    mChildMessageManager = InProcessTabChildMessageManager::Create(
+    mChildMessageManager = InProcessBrowserChildMessageManager::Create(
         GetDocShell(), mOwnerContent, mMessageManager);
     NS_ENSURE_TRUE(mChildMessageManager, NS_ERROR_UNEXPECTED);
   }
   return NS_OK;
 }
 
 nsresult nsFrameLoader::ReallyLoadFrameScripts() {
   nsresult rv = EnsureMessageManager();
@@ -3024,25 +3027,25 @@ nsresult nsFrameLoader::ReallyLoadFrameS
   }
   return NS_OK;
 }
 
 already_AddRefed<Element> nsFrameLoader::GetOwnerElement() {
   return do_AddRef(mOwnerContent);
 }
 
-void nsFrameLoader::SetRemoteBrowser(nsITabParent* aTabParent) {
-  MOZ_ASSERT(!mRemoteBrowser);
+void nsFrameLoader::SetRemoteBrowser(nsIRemoteTab* aBrowserParent) {
+  MOZ_ASSERT(!mBrowserParent);
   mIsRemoteFrame = true;
-  mRemoteBrowser = TabParent::GetFrom(aTabParent);
-  mChildID = mRemoteBrowser ? mRemoteBrowser->Manager()->ChildID() : 0;
-  MaybeUpdatePrimaryTabParent(eTabParentChanged);
+  mBrowserParent = BrowserParent::GetFrom(aBrowserParent);
+  mChildID = mBrowserParent ? mBrowserParent->Manager()->ChildID() : 0;
+  MaybeUpdatePrimaryBrowserParent(eBrowserParentChanged);
   ReallyLoadFrameScripts();
   InitializeBrowserAPI();
-  mRemoteBrowser->InitRendering();
+  mBrowserParent->InitRendering();
   ShowRemoteFrame(ScreenIntSize(0, 0));
 }
 
 void nsFrameLoader::SetDetachedSubdocFrame(nsIFrame* aDetachedFrame,
                                            Document* aContainerDoc) {
   mDetachedSubdocFrame = aDetachedFrame;
   mContainerDocWhileDetached = aContainerDoc;
 }
@@ -3091,17 +3094,17 @@ void nsFrameLoader::AttributeChanged(moz
 
   // Note: This logic duplicates a lot of logic in
   // MaybeCreateDocshell.  We should fix that.
 
   // Notify our enclosing chrome that our type has changed.  We only do this
   // if our parent is chrome, since in all other cases we're random content
   // subframes and the treeowner shouldn't worry about us.
   if (!GetDocShell()) {
-    MaybeUpdatePrimaryTabParent(eTabParentChanged);
+    MaybeUpdatePrimaryBrowserParent(eBrowserParentChanged);
     return;
   }
 
   nsCOMPtr<nsIDocShellTreeItem> parentItem;
   GetDocShell()->GetParent(getter_AddRefs(parentItem));
   if (!parentItem) {
     return;
   }
@@ -3135,50 +3138,50 @@ void nsFrameLoader::AttributeChanged(moz
     parentTreeOwner->ContentShellAdded(GetDocShell(), is_primary);
   }
 }
 
 /**
  * Send the RequestNotifyAfterRemotePaint message to the current Tab.
  */
 void nsFrameLoader::RequestNotifyAfterRemotePaint() {
-  // If remote browsing (e10s), handle this with the TabParent.
-  if (mRemoteBrowser) {
-    Unused << mRemoteBrowser->SendRequestNotifyAfterRemotePaint();
+  // If remote browsing (e10s), handle this with the BrowserParent.
+  if (mBrowserParent) {
+    Unused << mBrowserParent->SendRequestNotifyAfterRemotePaint();
   }
 }
 
 void nsFrameLoader::RequestUpdatePosition(ErrorResult& aRv) {
-  if (auto* tabParent = TabParent::GetFrom(GetRemoteBrowser())) {
-    nsresult rv = tabParent->UpdatePosition();
+  if (auto* browserParent = BrowserParent::GetFrom(GetRemoteBrowser())) {
+    nsresult rv = browserParent->UpdatePosition();
 
     if (NS_FAILED(rv)) {
       aRv.Throw(rv);
     }
   }
 }
 
 void nsFrameLoader::Print(uint64_t aOuterWindowID,
                           nsIPrintSettings* aPrintSettings,
                           nsIWebProgressListener* aProgressListener,
                           ErrorResult& aRv) {
 #if defined(NS_PRINTING)
-  if (mRemoteBrowser) {
+  if (mBrowserParent) {
     RefPtr<embedding::PrintingParent> printingParent =
-        mRemoteBrowser->Manager()->GetPrintingParent();
+        mBrowserParent->Manager()->GetPrintingParent();
 
     embedding::PrintData printData;
     nsresult rv = printingParent->SerializeAndEnsureRemotePrintJob(
         aPrintSettings, aProgressListener, nullptr, &printData);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       aRv.Throw(rv);
       return;
     }
 
-    bool success = mRemoteBrowser->SendPrint(aOuterWindowID, printData);
+    bool success = mBrowserParent->SendPrint(aOuterWindowID, printData);
     if (!success) {
       aRv.Throw(NS_ERROR_FAILURE);
     }
     return;
   }
 
   nsGlobalWindowOuter* outerWindow =
       nsGlobalWindowOuter::GetOuterWindowWithId(aOuterWindowID);
@@ -3229,51 +3232,51 @@ already_AddRefed<mozilla::dom::Promise> 
           set, NS_RGB(0, 0, 0), aBackgroundColor, &color, nullptr, loader))) {
     aRv = NS_ERROR_FAILURE;
     return nullptr;
   }
 
   gfx::IntRect rect = gfx::IntRect::RoundOut(gfx::Rect(aX, aY, aW, aH));
 
   if (IsRemoteFrame()) {
-    gfx::CrossProcessPaint::StartRemote(mRemoteBrowser->GetTabId(), rect,
+    gfx::CrossProcessPaint::StartRemote(mBrowserParent->GetTabId(), rect,
                                         aScale, color, promise);
   } else {
     gfx::CrossProcessPaint::StartLocal(GetDocShell(), rect, aScale, color,
                                        promise);
   }
 
   return promise.forget();
 }
 
-already_AddRefed<nsITabParent> nsFrameLoader::GetTabParent() {
-  return do_AddRef(mRemoteBrowser);
+already_AddRefed<nsIRemoteTab> nsFrameLoader::GetRemoteTab() {
+  return do_AddRef(mBrowserParent);
 }
 
 already_AddRefed<nsILoadContext> nsFrameLoader::LoadContext() {
   nsCOMPtr<nsILoadContext> loadContext;
   if (IsRemoteFrame() &&
-      (mRemoteBrowser || mBrowserBridgeChild || TryRemoteBrowser())) {
-    if (mRemoteBrowser) {
-      loadContext = mRemoteBrowser->GetLoadContext();
+      (mBrowserParent || mBrowserBridgeChild || TryRemoteBrowser())) {
+    if (mBrowserParent) {
+      loadContext = mBrowserParent->GetLoadContext();
     } else {
       loadContext = mBrowserBridgeChild->GetLoadContext();
     }
   } else {
     loadContext = do_GetInterface(ToSupports(GetDocShell(IgnoreErrors())));
   }
   return loadContext.forget();
 }
 
 already_AddRefed<BrowsingContext> nsFrameLoader::GetBrowsingContext() {
   RefPtr<BrowsingContext> browsingContext;
   if (IsRemoteFrame() &&
-      (mRemoteBrowser || mBrowserBridgeChild || TryRemoteBrowser())) {
-    if (mRemoteBrowser) {
-      browsingContext = mRemoteBrowser->GetBrowsingContext();
+      (mBrowserParent || mBrowserBridgeChild || TryRemoteBrowser())) {
+    if (mBrowserParent) {
+      browsingContext = mBrowserParent->GetBrowsingContext();
     } else {
       browsingContext = mBrowserBridgeChild->GetBrowsingContext();
     }
   } else if (GetDocShell(IgnoreErrors())) {
     browsingContext = GetDocShell()->GetBrowsingContext();
   }
   return browsingContext.forget();
 }
@@ -3310,18 +3313,18 @@ void nsFrameLoader::DestroyBrowserFrameS
   }
 }
 
 void nsFrameLoader::StartPersistence(
     uint64_t aOuterWindowID, nsIWebBrowserPersistDocumentReceiver* aRecv,
     ErrorResult& aRv) {
   MOZ_ASSERT(aRecv);
 
-  if (mRemoteBrowser) {
-    mRemoteBrowser->StartPersistence(aOuterWindowID, aRecv, aRv);
+  if (mBrowserParent) {
+    mBrowserParent->StartPersistence(aOuterWindowID, aRecv, aRv);
     return;
   }
 
   nsCOMPtr<Document> rootDoc =
       GetDocShell() ? GetDocShell()->GetDocument() : nullptr;
   nsCOMPtr<Document> foundDoc;
   if (aOuterWindowID) {
     foundDoc = nsContentUtils::GetSubdocumentWithOuterWindowId(rootDoc,
@@ -3334,18 +3337,19 @@ void nsFrameLoader::StartPersistence(
     aRecv->OnError(NS_ERROR_NO_CONTENT);
   } else {
     nsCOMPtr<nsIWebBrowserPersistDocument> pdoc =
         new mozilla::WebBrowserPersistLocalDocument(foundDoc);
     aRecv->OnDocumentReady(pdoc);
   }
 }
 
-void nsFrameLoader::MaybeUpdatePrimaryTabParent(TabParentChange aChange) {
-  if (mRemoteBrowser && mOwnerContent) {
+void nsFrameLoader::MaybeUpdatePrimaryBrowserParent(
+    BrowserParentChange aChange) {
+  if (mBrowserParent && mOwnerContent) {
     nsCOMPtr<nsIDocShell> docShell = mOwnerContent->OwnerDoc()->GetDocShell();
     if (!docShell) {
       return;
     }
 
     int32_t parentType = docShell->ItemType();
     if (parentType != nsIDocShellTreeItem::typeChrome) {
       return;
@@ -3357,21 +3361,21 @@ void nsFrameLoader::MaybeUpdatePrimaryTa
       return;
     }
 
     if (!mObservingOwnerContent) {
       mOwnerContent->AddMutationObserver(this);
       mObservingOwnerContent = true;
     }
 
-    parentTreeOwner->TabParentRemoved(mRemoteBrowser);
-    if (aChange == eTabParentChanged) {
+    parentTreeOwner->RemoteTabRemoved(mBrowserParent);
+    if (aChange == eBrowserParentChanged) {
       bool isPrimary = mOwnerContent->AttrValueIs(
           kNameSpaceID_None, nsGkAtoms::primary, nsGkAtoms::_true, eIgnoreCase);
-      parentTreeOwner->TabParentAdded(mRemoteBrowser, isPrimary);
+      parentTreeOwner->RemoteTabAdded(mBrowserParent, isPrimary);
     }
   }
 }
 
 nsresult nsFrameLoader::GetNewTabContext(MutableTabContext* aTabContext,
                                          nsIURI* aURI) {
   OriginAttributes attrs;
   attrs.mInIsolatedMozBrowser = OwnerIsIsolatedMozBrowserFrame();
@@ -3439,17 +3443,17 @@ nsresult nsFrameLoader::PopulateUserCont
       NS_ENSURE_SUCCESS(rv, rv);
     }
   }
 
   return NS_OK;
 }
 
 ProcessMessageManager* nsFrameLoader::GetProcessMessageManager() const {
-  return mRemoteBrowser ? mRemoteBrowser->Manager()->GetMessageManager()
+  return mBrowserParent ? mBrowserParent->Manager()->GetMessageManager()
                         : nullptr;
 };
 
 JSObject* nsFrameLoader::WrapObject(JSContext* cx,
                                     JS::Handle<JSObject*> aGivenProto) {
   JS::RootedObject result(cx);
   FrameLoader_Binding::Wrap(cx, this, this, aGivenProto, &result);
   return result;
--- a/dom/base/nsFrameLoader.h
+++ b/dom/base/nsFrameLoader.h
@@ -31,38 +31,38 @@
 #include "nsPluginTags.h"
 
 class nsIURI;
 class nsSubDocumentFrame;
 class nsView;
 class AutoResetInShow;
 class AutoResetInFrameSwap;
 class nsFrameLoaderOwner;
-class nsITabParent;
+class nsIRemoteTab;
 class nsIDocShellTreeItem;
 class nsIDocShellTreeOwner;
 class nsILoadContext;
 class nsIMessageSender;
 class nsIPrintSettings;
 class nsIWebBrowserPersistDocumentReceiver;
 class nsIWebProgressListener;
 
 namespace mozilla {
 
 class OriginAttributes;
 
 namespace dom {
 class ChromeMessageSender;
 class ContentParent;
-class InProcessTabChildMessageManager;
+class InProcessBrowserChildMessageManager;
 class MessageSender;
 class PBrowserParent;
 class ProcessMessageManager;
 class Promise;
-class TabParent;
+class BrowserParent;
 class MutableTabContext;
 class BrowserBridgeChild;
 class RemoteFrameChild;
 struct RemotenessOptions;
 
 namespace ipc {
 class StructuredCloneData;
 }  // namespace ipc
@@ -88,17 +88,17 @@ typedef struct _GtkWidget GtkWidget;
 
 class nsFrameLoader final : public nsStubMutationObserver,
                             public mozilla::dom::ipc::MessageManagerCallback,
                             public nsWrapperCache {
   friend class AutoResetInShow;
   friend class AutoResetInFrameSwap;
   typedef mozilla::dom::PBrowserParent PBrowserParent;
   typedef mozilla::dom::Document Document;
-  typedef mozilla::dom::TabParent TabParent;
+  typedef mozilla::dom::BrowserParent BrowserParent;
   typedef mozilla::layout::RenderFrame RenderFrame;
 
  public:
   // Called by Frame Elements to create a new FrameLoader.
   static nsFrameLoader* Create(mozilla::dom::Element* aOwner,
                                mozilla::dom::BrowsingContext* aOpener,
                                bool aNetworkCreated);
 
@@ -116,28 +116,28 @@ class nsFrameLoader final : public nsStu
   nsresult CheckForRecursiveLoad(nsIURI* aURI);
   nsresult ReallyStartLoading();
   void StartDestroy();
   void DestroyDocShell();
   void DestroyComplete();
   nsIDocShell* GetExistingDocShell() const {
     return mBrowsingContext ? mBrowsingContext->GetDocShell() : nullptr;
   }
-  mozilla::dom::InProcessTabChildMessageManager* GetTabChildMessageManager()
-      const {
+  mozilla::dom::InProcessBrowserChildMessageManager*
+  GetBrowserChildMessageManager() const {
     return mChildMessageManager;
   }
   nsresult CreateStaticClone(nsFrameLoader* aDest);
   nsresult UpdatePositionAndSize(nsSubDocumentFrame* aIFrame);
 
   // WebIDL methods
 
   nsDocShell* GetDocShell(mozilla::ErrorResult& aRv);
 
-  already_AddRefed<nsITabParent> GetTabParent();
+  already_AddRefed<nsIRemoteTab> GetRemoteTab();
 
   already_AddRefed<nsILoadContext> LoadContext();
 
   already_AddRefed<mozilla::dom::BrowsingContext> GetBrowsingContext();
 
   /**
    * Start loading the frame. This method figures out what to load
    * from the owner content in the frame loader.
@@ -323,22 +323,22 @@ class nsFrameLoader final : public nsStu
 
   mozilla::dom::Element* GetOwnerContent() { return mOwnerContent; }
 
   mozilla::dom::ParentSHistory* GetParentSHistory() { return mParentSHistory; }
 
   /**
    * Tell this FrameLoader to use a particular remote browser.
    *
-   * This will assert if mRemoteBrowser is non-null.  In practice,
+   * This will assert if mBrowserParent is non-null.  In practice,
    * this means you can't have successfully run TryRemoteBrowser() on
    * this object, which means you can't have called ShowRemoteFrame()
    * or ReallyStartLoading().
    */
-  void SetRemoteBrowser(nsITabParent* aTabParent);
+  void SetRemoteBrowser(nsIRemoteTab* aBrowserParent);
 
   /**
    * Stashes a detached nsIFrame on the frame loader. We do this when we're
    * destroying the nsSubDocumentFrame. If the nsSubdocumentFrame is
    * being reframed we'll restore the detached nsIFrame when it's recreated,
    * otherwise we'll discard the old presentation and set the detached
    * subdoc nsIFrame to null. aContainerDoc is the document containing the
    * the subdoc frame. This enables us to detect when the containing
@@ -367,17 +367,18 @@ class nsFrameLoader final : public nsStu
   // Properly retrieves documentSize of any subdocument type.
   nsresult GetWindowDimensions(nsIntRect& aRect);
 
   virtual mozilla::dom::ProcessMessageManager* GetProcessMessageManager()
       const override;
 
   // public because a callback needs these.
   RefPtr<mozilla::dom::ChromeMessageSender> mMessageManager;
-  RefPtr<mozilla::dom::InProcessTabChildMessageManager> mChildMessageManager;
+  RefPtr<mozilla::dom::InProcessBrowserChildMessageManager>
+      mChildMessageManager;
 
   virtual JSObject* WrapObject(JSContext* cx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
  private:
   nsFrameLoader(mozilla::dom::Element* aOwner,
                 mozilla::dom::BrowsingContext* aBrowsingContext,
                 bool aNetworkCreated);
@@ -444,18 +445,18 @@ class nsFrameLoader final : public nsStu
                               nsIDocShellTreeOwner* aOwner);
 
   void InitializeBrowserAPI();
   void DestroyBrowserFrameScripts();
 
   nsresult GetNewTabContext(mozilla::dom::MutableTabContext* aTabContext,
                             nsIURI* aURI = nullptr);
 
-  enum TabParentChange { eTabParentRemoved, eTabParentChanged };
-  void MaybeUpdatePrimaryTabParent(TabParentChange aChange);
+  enum BrowserParentChange { eBrowserParentRemoved, eBrowserParentChanged };
+  void MaybeUpdatePrimaryBrowserParent(BrowserParentChange aChange);
 
   nsresult PopulateUserContextIdFromAttribute(mozilla::OriginAttributes& aAttr);
 
   RefPtr<mozilla::dom::BrowsingContext> mBrowsingContext;
   nsCOMPtr<nsIURI> mURIToLoad;
   nsCOMPtr<nsIPrincipal> mTriggeringPrincipal;
   nsCOMPtr<nsIContentSecurityPolicy> mCsp;
   mozilla::dom::Element* mOwnerContent;  // WEAK
@@ -475,17 +476,17 @@ class nsFrameLoader final : public nsStu
   // a reframe, so that we know not to restore the presentation.
   RefPtr<Document> mContainerDocWhileDetached;
 
   // When performing a process switch, this value is used rather than mURIToLoad
   // to identify the process-switching load which should be resumed in the
   // target process.
   uint64_t mPendingSwitchID;
 
-  RefPtr<TabParent> mRemoteBrowser;
+  RefPtr<BrowserParent> mBrowserParent;
   uint64_t mChildID;
 
   // This is used when this refers to a remote sub frame
   RefPtr<mozilla::dom::BrowserBridgeChild> mBrowserBridgeChild;
 
   // Holds the last known size of the frame.
   mozilla::ScreenIntSize mLazySize;
 
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -739,17 +739,17 @@ void nsFrameMessageManager::ReceiveMessa
       if (aTargetFrameLoader) {
         argument.mTargetFrameLoader.Construct(*aTargetFrameLoader);
       }
 
       JS::Rooted<JS::Value> thisValue(cx, JS::UndefinedValue());
 
       if (JS::IsCallable(object)) {
         // A small hack to get 'this' value right on content side where
-        // messageManager is wrapped in TabChildMessageManager's global.
+        // messageManager is wrapped in BrowserChildMessageManager's global.
         nsCOMPtr<nsISupports> defaultThisValue;
         if (mChrome) {
           defaultThisValue = do_QueryObject(this);
         } else {
           defaultThisValue = aTarget;
         }
         js::AssertSameCompartment(cx, object);
         aError = nsContentUtils::WrapNative(cx, defaultThisValue, &thisValue);
--- a/dom/base/nsGlobalWindowInner.cpp
+++ b/dom/base/nsGlobalWindowInner.cpp
@@ -224,17 +224,17 @@
 #include "mozilla/dom/FunctionBinding.h"
 #include "mozilla/dom/HashChangeEvent.h"
 #include "mozilla/dom/IntlUtils.h"
 #include "mozilla/dom/PopStateEvent.h"
 #include "mozilla/dom/PopupBlocker.h"
 #include "mozilla/dom/PopupBlockedEvent.h"
 #include "mozilla/dom/PrimitiveConversions.h"
 #include "mozilla/dom/WindowBinding.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 #include "mozilla/dom/LoadedScript.h"
 #include "mozilla/dom/MediaQueryList.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/dom/NavigatorBinding.h"
 #include "mozilla/dom/ImageBitmap.h"
 #include "mozilla/dom/ImageBitmapBinding.h"
 #include "mozilla/dom/InstallTriggerBinding.h"
 #include "mozilla/dom/Report.h"
@@ -900,17 +900,17 @@ nsGlobalWindowInner::nsGlobalWindowInner
   RefPtr<StorageNotifierService> sns = StorageNotifierService::GetOrCreate();
   if (sns) {
     sns->Register(mObserver);
   }
 
   if (XRE_IsContentProcess()) {
     nsCOMPtr<nsIDocShell> docShell = GetDocShell();
     if (docShell) {
-      mTabChild = docShell->GetTabChild();
+      mBrowserChild = docShell->GetBrowserChild();
     }
   }
 
   // We could have failed the first time through trying
   // to create the entropy collector, so we should
   // try to get one until we succeed.
 
   static bool sFirstTime = true;
@@ -1175,20 +1175,20 @@ void nsGlobalWindowInner::FreeInnerObjec
   DisableVRUpdates();
   mHasVREvents = false;
   mHasVRDisplayActivateEvents = false;
   mVRDisplays.Clear();
 
   // This breaks a cycle between the window and the ClientSource object.
   mClientSource.reset();
 
-  if (mTabChild) {
+  if (mBrowserChild) {
     // Remove any remaining listeners, and reset mBeforeUnloadListenerCount.
     for (int i = 0; i < mBeforeUnloadListenerCount; ++i) {
-      mTabChild->BeforeUnloadRemoved();
+      mBrowserChild->BeforeUnloadRemoved();
     }
     mBeforeUnloadListenerCount = 0;
   }
 
   // If we have any promiseDocumentFlushed callbacks, fire them now so
   // that the Promises can resolve.
   CallDocumentFlushedResolvers();
   mObservingDidRefresh = false;
@@ -1354,17 +1354,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCustomElements)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSharedWorkers)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocalStorage)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSessionStorage)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mApplicationCache)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIndexedDB)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentPrincipal)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentStoragePrincipal)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTabChild)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChild)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDoc)
 
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleRequestExecutor)
   for (IdleRequest* request : tmp->mIdleRequestCallbacks) {
     cb.NoteNativeChild(request, NS_CYCLE_COLLECTION_PARTICIPANT(IdleRequest));
   }
 
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mClientSource)
@@ -1458,17 +1458,17 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ns
     NS_IMPL_CYCLE_COLLECTION_UNLINK(mApplicationCache)
   }
   if (tmp->mIndexedDB) {
     tmp->mIndexedDB->DisconnectFromGlobal(tmp);
     NS_IMPL_CYCLE_COLLECTION_UNLINK(mIndexedDB)
   }
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentPrincipal)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentStoragePrincipal)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTabChild)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChild)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDoc)
 
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGamepads)
 
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCacheStorage)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mVRDisplays)
 
   // Unlink stuff from nsPIDOMWindow
@@ -1609,21 +1609,21 @@ void nsGlobalWindowInner::InnerSetNewDoc
 
   // This must be called after nullifying the internal objects because here we
   // could recreate them, calling the getter methods, and store them into the JS
   // slots. If we nullify them after, the slot values and the objects will be
   // out of sync.
   ClearDocumentDependentSlots(aCx);
 
   // FIXME: Currently, devtools can crete a fallback webextension window global
-  // in the content process which does not have a corresponding TabChild actor.
-  // This means we have no actor to be our parent. (Bug 1498293)
+  // in the content process which does not have a corresponding BrowserChild
+  // actor. This means we have no actor to be our parent. (Bug 1498293)
   MOZ_DIAGNOSTIC_ASSERT(!mWindowGlobalChild,
                         "Shouldn't have created WindowGlobalChild yet!");
-  if (XRE_IsParentProcess() || mTabChild) {
+  if (XRE_IsParentProcess() || mBrowserChild) {
     mWindowGlobalChild = WindowGlobalChild::Create(this);
   }
 
   if (ShouldResetBrowsingContextUserGestureActivation()) {
     Window()->NotifyResetUserGestureActivation();
   }
 
 #ifdef DEBUG
@@ -1828,28 +1828,28 @@ void nsGlobalWindowInner::UpdateParentTa
 
   // Try to get our frame element's tab child global (its in-process message
   // manager).  If that fails, fall back to the chrome event handler's tab
   // child global, and if it doesn't have one, just use the chrome event
   // handler itself.
 
   nsCOMPtr<Element> frameElement = GetOuterWindow()->GetFrameElementInternal();
   nsCOMPtr<EventTarget> eventTarget =
-      nsContentUtils::TryGetTabChildGlobal(frameElement);
+      nsContentUtils::TryGetBrowserChildGlobal(frameElement);
 
   if (!eventTarget) {
     nsGlobalWindowOuter* topWin = GetScriptableTopInternal();
     if (topWin) {
       frameElement = topWin->GetFrameElementInternal();
-      eventTarget = nsContentUtils::TryGetTabChildGlobal(frameElement);
+      eventTarget = nsContentUtils::TryGetBrowserChildGlobal(frameElement);
     }
   }
 
   if (!eventTarget) {
-    eventTarget = nsContentUtils::TryGetTabChildGlobal(mChromeEventHandler);
+    eventTarget = nsContentUtils::TryGetBrowserChildGlobal(mChromeEventHandler);
   }
 
   if (!eventTarget) {
     eventTarget = mChromeEventHandler;
   }
 
   mParentTarget = eventTarget;
 }
@@ -4611,17 +4611,18 @@ nsGlobalWindowInner::ShowSlowScriptDialo
     Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_PAGE_COUNT, 1);
   }
   mHasHadSlowScript = true;
 
   if (XRE_IsContentProcess() && ProcessHangMonitor::Get()) {
     ProcessHangMonitor::SlowScriptAction action;
     RefPtr<ProcessHangMonitor> monitor = ProcessHangMonitor::Get();
     nsIDocShell* docShell = GetDocShell();
-    nsCOMPtr<nsITabChild> child = docShell ? docShell->GetTabChild() : nullptr;
+    nsCOMPtr<nsIBrowserChild> child =
+        docShell ? docShell->GetBrowserChild() : nullptr;
     action = monitor->NotifySlowScript(child, filename.get(), aAddonId);
     if (action == ProcessHangMonitor::Terminate) {
       return KillSlowScript;
     }
     if (action == ProcessHangMonitor::TerminateGlobal) {
       return KillScriptGlobal;
     }
 
@@ -5834,21 +5835,21 @@ void nsGlobalWindowInner::EventListenerA
       aType == nsGkAtoms::onvrdisplaypresentchange) {
     NotifyVREventListenerAdded();
   }
 
   if (aType == nsGkAtoms::onvrdisplayactivate) {
     mHasVRDisplayActivateEvents = true;
   }
 
-  if (aType == nsGkAtoms::onbeforeunload && mTabChild &&
+  if (aType == nsGkAtoms::onbeforeunload && mBrowserChild &&
       (!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS))) {
     mBeforeUnloadListenerCount++;
     MOZ_ASSERT(mBeforeUnloadListenerCount > 0);
-    mTabChild->BeforeUnloadAdded();
+    mBrowserChild->BeforeUnloadAdded();
   }
 
   // We need to initialize localStorage in order to receive notifications.
   if (aType == nsGkAtoms::onstorage) {
     ErrorResult rv;
     GetLocalStorage(rv);
     rv.SuppressException();
 
@@ -5857,21 +5858,21 @@ void nsGlobalWindowInner::EventListenerA
       auto object = static_cast<LSObject*>(mLocalStorage.get());
 
       Unused << NS_WARN_IF(NS_FAILED(object->EnsureObserver()));
     }
   }
 }
 
 void nsGlobalWindowInner::EventListenerRemoved(nsAtom* aType) {
-  if (aType == nsGkAtoms::onbeforeunload && mTabChild &&
+  if (aType == nsGkAtoms::onbeforeunload && mBrowserChild &&
       (!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS))) {
     mBeforeUnloadListenerCount--;
     MOZ_ASSERT(mBeforeUnloadListenerCount >= 0);
-    mTabChild->BeforeUnloadRemoved();
+    mBrowserChild->BeforeUnloadRemoved();
   }
 
   if (aType == nsGkAtoms::onstorage) {
     if (NextGenLocalStorageEnabled() && mLocalStorage &&
         mLocalStorage->Type() == Storage::eLocalStorage &&
         // The remove event is fired even if this isn't the last listener, so
         // only remove if there are no other listeners left.
         mListenerManager &&
--- a/dom/base/nsGlobalWindowInner.h
+++ b/dom/base/nsGlobalWindowInner.h
@@ -66,17 +66,17 @@ class nsIContent;
 class nsICSSDeclaration;
 class nsIDocShellTreeOwner;
 class nsIDOMWindowUtils;
 class nsDOMOfflineResourceList;
 class nsIScrollableFrame;
 class nsIControllers;
 class nsIScriptContext;
 class nsIScriptTimeoutHandler;
-class nsITabChild;
+class nsIBrowserChild;
 class nsITimeoutHandler;
 class nsIWebBrowserChrome;
 class mozIDOMWindowProxy;
 
 class nsDOMWindowList;
 class nsScreen;
 class nsHistory;
 class nsGlobalWindowObserver;
@@ -1293,18 +1293,18 @@ class nsGlobalWindowInner final : public
 
   nsTObserverArray<RefPtr<mozilla::dom::SharedWorker>> mSharedWorkers;
 
   RefPtr<mozilla::dom::VisualViewport> mVisualViewport;
 
   nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
   nsCOMPtr<nsIPrincipal> mDocumentStoragePrincipal;
 
-  // mTabChild is only ever populated in the content process.
-  nsCOMPtr<nsITabChild> mTabChild;
+  // mBrowserChild is only ever populated in the content process.
+  nsCOMPtr<nsIBrowserChild> mBrowserChild;
 
   uint32_t mSuspendDepth;
   uint32_t mFreezeDepth;
 
 #ifdef DEBUG
   uint32_t mSerial;
 #endif
 
--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -224,17 +224,17 @@
 #include "mozilla/dom/Fetch.h"
 #include "mozilla/dom/FunctionBinding.h"
 #include "mozilla/dom/HashChangeEvent.h"
 #include "mozilla/dom/IntlUtils.h"
 #include "mozilla/dom/PopStateEvent.h"
 #include "mozilla/dom/PopupBlockedEvent.h"
 #include "mozilla/dom/PrimitiveConversions.h"
 #include "mozilla/dom/WindowBinding.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 #include "mozilla/dom/MediaQueryList.h"
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/dom/NavigatorBinding.h"
 #include "mozilla/dom/ImageBitmap.h"
 #include "mozilla/dom/ImageBitmapBinding.h"
 #include "mozilla/dom/ServiceWorkerRegistration.h"
 #include "mozilla/dom/U2F.h"
 #include "mozilla/dom/WebIDLGlobalNameHash.h"
@@ -2560,28 +2560,29 @@ void nsGlobalWindowOuter::UpdateParentTa
   // mMessageManager as well, which inner windows don't have.
 
   // Try to get our frame element's tab child global (its in-process message
   // manager).  If that fails, fall back to the chrome event handler's tab
   // child global, and if it doesn't have one, just use the chrome event
   // handler itself.
 
   nsCOMPtr<Element> frameElement = GetFrameElementInternal();
-  mMessageManager = nsContentUtils::TryGetTabChildGlobal(frameElement);
+  mMessageManager = nsContentUtils::TryGetBrowserChildGlobal(frameElement);
 
   if (!mMessageManager) {
     nsGlobalWindowOuter* topWin = GetScriptableTopInternal();
     if (topWin) {
       frameElement = topWin->GetFrameElementInternal();
-      mMessageManager = nsContentUtils::TryGetTabChildGlobal(frameElement);
+      mMessageManager = nsContentUtils::TryGetBrowserChildGlobal(frameElement);
     }
   }
 
   if (!mMessageManager) {
-    mMessageManager = nsContentUtils::TryGetTabChildGlobal(mChromeEventHandler);
+    mMessageManager =
+        nsContentUtils::TryGetBrowserChildGlobal(mChromeEventHandler);
   }
 
   if (mMessageManager) {
     mParentTarget = mMessageManager;
   } else {
     mParentTarget = mChromeEventHandler;
   }
 }
@@ -4646,17 +4647,17 @@ bool nsGlobalWindowOuter::CanMoveResizeW
     if (!CanSetProperty("dom.disable_window_move_resize")) {
       return false;
     }
 
     // Ignore the request if we have more than one tab in the window.
     if (XRE_IsContentProcess()) {
       nsCOMPtr<nsIDocShell> docShell = GetDocShell();
       if (docShell) {
-        nsCOMPtr<nsITabChild> child = docShell->GetTabChild();
+        nsCOMPtr<nsIBrowserChild> child = docShell->GetBrowserChild();
         bool hasSiblings = true;
         if (child && NS_SUCCEEDED(child->GetHasSiblings(&hasSiblings)) &&
             hasSiblings) {
           return false;
         }
       }
     } else {
       nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
@@ -6459,37 +6460,37 @@ Element* nsGlobalWindowOuter::GetRealFra
  */
 Element* nsGlobalWindowOuter::GetFrameElement() {
   FORWARD_TO_INNER(GetFrameElement, (), nullptr);
 }
 
 namespace {
 class ChildCommandDispatcher : public Runnable {
  public:
-  ChildCommandDispatcher(nsPIWindowRoot* aRoot, nsITabChild* aTabChild,
+  ChildCommandDispatcher(nsPIWindowRoot* aRoot, nsIBrowserChild* aBrowserChild,
                          const nsAString& aAction)
       : mozilla::Runnable("ChildCommandDispatcher"),
         mRoot(aRoot),
-        mTabChild(aTabChild),
+        mBrowserChild(aBrowserChild),
         mAction(aAction) {}
 
   NS_IMETHOD Run() override {
     nsTArray<nsCString> enabledCommands, disabledCommands;
     mRoot->GetEnabledDisabledCommands(enabledCommands, disabledCommands);
     if (enabledCommands.Length() || disabledCommands.Length()) {
-      mTabChild->EnableDisableCommands(mAction, enabledCommands,
-                                       disabledCommands);
+      mBrowserChild->EnableDisableCommands(mAction, enabledCommands,
+                                           disabledCommands);
     }
 
     return NS_OK;
   }
 
  private:
   nsCOMPtr<nsPIWindowRoot> mRoot;
-  nsCOMPtr<nsITabChild> mTabChild;
+  nsCOMPtr<nsIBrowserChild> mBrowserChild;
   nsString mAction;
 };
 
 class CommandDispatcher : public Runnable {
  public:
   CommandDispatcher(nsIDOMXULCommandDispatcher* aDispatcher,
                     const nsAString& aAction)
       : mozilla::Runnable("CommandDispatcher"),
@@ -6502,17 +6503,17 @@ class CommandDispatcher : public Runnabl
   nsString mAction;
 };
 }  // anonymous namespace
 
 void nsGlobalWindowOuter::UpdateCommands(const nsAString& anAction,
                                          Selection* aSel, int16_t aReason) {
   // If this is a child process, redirect to the parent process.
   if (nsIDocShell* docShell = GetDocShell()) {
-    if (nsCOMPtr<nsITabChild> child = docShell->GetTabChild()) {
+    if (nsCOMPtr<nsIBrowserChild> child = docShell->GetBrowserChild()) {
       nsCOMPtr<nsPIWindowRoot> root = GetTopWindowRoot();
       if (root) {
         nsContentUtils::AddScriptRunner(
             new ChildCommandDispatcher(root, child, anAction));
       }
       return;
     }
   }
--- a/dom/base/nsGlobalWindowOuter.h
+++ b/dom/base/nsGlobalWindowOuter.h
@@ -63,17 +63,17 @@ class nsIBaseWindow;
 class nsIContent;
 class nsICSSDeclaration;
 class nsIDocShellTreeOwner;
 class nsIDOMWindowUtils;
 class nsIScrollableFrame;
 class nsIControllers;
 class nsIScriptContext;
 class nsIScriptTimeoutHandler;
-class nsITabChild;
+class nsIBrowserChild;
 class nsITimeoutHandler;
 class nsIWebBrowserChrome;
 class mozIDOMWindowProxy;
 
 class nsDocShellLoadState;
 class nsDOMWindowList;
 class nsScreen;
 class nsHistory;
--- a/dom/base/nsPIWindowRoot.h
+++ b/dom/base/nsPIWindowRoot.h
@@ -12,17 +12,17 @@
 
 class nsPIDOMWindowOuter;
 class nsIControllers;
 class nsIController;
 class nsINode;
 
 namespace mozilla {
 namespace dom {
-class TabParent;
+class BrowserParent;
 }  // namespace dom
 }  // namespace mozilla
 
 #define NS_IWINDOWROOT_IID                           \
   {                                                  \
     0xb8724c49, 0xc398, 0x4f9b, {                    \
       0x82, 0x59, 0x87, 0x27, 0xa6, 0x47, 0xdd, 0x0f \
     }                                                \
@@ -56,20 +56,21 @@ class nsPIWindowRoot : public mozilla::d
   virtual void GetEnabledDisabledCommands(
       nsTArray<nsCString>& aEnabledCommands,
       nsTArray<nsCString>& aDisabledCommands) = 0;
 
   virtual void SetParentTarget(mozilla::dom::EventTarget* aTarget) = 0;
   virtual mozilla::dom::EventTarget* GetParentTarget() = 0;
 
   // Stores a weak reference to the browser.
-  virtual void AddBrowser(mozilla::dom::TabParent* aBrowser) = 0;
-  virtual void RemoveBrowser(mozilla::dom::TabParent* aBrowser) = 0;
+  virtual void AddBrowser(mozilla::dom::BrowserParent* aBrowser) = 0;
+  virtual void RemoveBrowser(mozilla::dom::BrowserParent* aBrowser) = 0;
 
-  typedef void (*BrowserEnumerator)(mozilla::dom::TabParent* aTab, void* aArg);
+  typedef void (*BrowserEnumerator)(mozilla::dom::BrowserParent* aTab,
+                                    void* aArg);
 
   // Enumerate all stored browsers that for which the weak reference is valid.
   virtual void EnumerateBrowsers(BrowserEnumerator aEnumFunc, void* aArg) = 0;
 
   virtual bool ShowAccelerators() = 0;
   virtual bool ShowFocusRings() = 0;
   virtual void SetShowAccelerators(bool aEnable) = 0;
   virtual void SetShowFocusRings(bool aEnable) = 0;
--- a/dom/base/nsWindowRoot.cpp
+++ b/dom/base/nsWindowRoot.cpp
@@ -17,17 +17,17 @@
 #include "nsString.h"
 #include "nsGlobalWindow.h"
 #include "nsFocusManager.h"
 #include "nsIContent.h"
 #include "nsIControllers.h"
 #include "nsIController.h"
 #include "xpcpublic.h"
 #include "nsCycleCollectionParticipant.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/dom/HTMLTextAreaElement.h"
 #include "mozilla/dom/HTMLInputElement.h"
 #include "mozilla/dom/JSWindowActorService.h"
 
 #ifdef MOZ_XUL
 #  include "nsXULElement.h"
 #endif
 
@@ -295,41 +295,42 @@ nsIGlobalObject* nsWindowRoot::GetParent
   return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
 }
 
 JSObject* nsWindowRoot::WrapObject(JSContext* aCx,
                                    JS::Handle<JSObject*> aGivenProto) {
   return mozilla::dom::WindowRoot_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-void nsWindowRoot::AddBrowser(mozilla::dom::TabParent* aBrowser) {
+void nsWindowRoot::AddBrowser(mozilla::dom::BrowserParent* aBrowser) {
   nsWeakPtr weakBrowser =
-      do_GetWeakReference(static_cast<nsITabParent*>(aBrowser));
+      do_GetWeakReference(static_cast<nsIRemoteTab*>(aBrowser));
   mWeakBrowsers.PutEntry(weakBrowser);
 }
 
-void nsWindowRoot::RemoveBrowser(mozilla::dom::TabParent* aBrowser) {
+void nsWindowRoot::RemoveBrowser(mozilla::dom::BrowserParent* aBrowser) {
   nsWeakPtr weakBrowser =
-      do_GetWeakReference(static_cast<nsITabParent*>(aBrowser));
+      do_GetWeakReference(static_cast<nsIRemoteTab*>(aBrowser));
   mWeakBrowsers.RemoveEntry(weakBrowser);
 }
 
 void nsWindowRoot::EnumerateBrowsers(BrowserEnumerator aEnumFunc, void* aArg) {
   // Collect strong references to all browsers in a separate array in
   // case aEnumFunc alters mWeakBrowsers.
-  nsTArray<RefPtr<TabParent>> tabParents;
+  nsTArray<RefPtr<BrowserParent>> browserParents;
   for (auto iter = mWeakBrowsers.ConstIter(); !iter.Done(); iter.Next()) {
-    nsCOMPtr<nsITabParent> tabParent(do_QueryReferent(iter.Get()->GetKey()));
-    if (TabParent* tab = TabParent::GetFrom(tabParent)) {
-      tabParents.AppendElement(tab);
+    nsCOMPtr<nsIRemoteTab> browserParent(
+        do_QueryReferent(iter.Get()->GetKey()));
+    if (BrowserParent* tab = BrowserParent::GetFrom(browserParent)) {
+      browserParents.AppendElement(tab);
     }
   }
 
-  for (uint32_t i = 0; i < tabParents.Length(); ++i) {
-    aEnumFunc(tabParents[i], aArg);
+  for (uint32_t i = 0; i < browserParents.Length(); ++i) {
+    aEnumFunc(browserParents[i], aArg);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 already_AddRefed<EventTarget> NS_NewWindowRoot(nsPIDOMWindowOuter* aWindow) {
   nsCOMPtr<EventTarget> result = new nsWindowRoot(aWindow);
 
--- a/dom/base/nsWindowRoot.h
+++ b/dom/base/nsWindowRoot.h
@@ -65,18 +65,18 @@ class nsWindowRoot final : public nsPIWi
 
   nsIGlobalObject* GetParentObject();
 
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsWindowRoot)
 
-  virtual void AddBrowser(mozilla::dom::TabParent* aBrowser) override;
-  virtual void RemoveBrowser(mozilla::dom::TabParent* aBrowser) override;
+  virtual void AddBrowser(mozilla::dom::BrowserParent* aBrowser) override;
+  virtual void RemoveBrowser(mozilla::dom::BrowserParent* aBrowser) override;
   virtual void EnumerateBrowsers(BrowserEnumerator aEnumFunc,
                                  void* aArg) override;
 
   virtual bool ShowAccelerators() override { return mShowAccelerators; }
 
   virtual bool ShowFocusRings() override { return mShowFocusRings; }
 
   virtual void SetShowAccelerators(bool aEnable) override {
@@ -104,17 +104,18 @@ class nsWindowRoot final : public nsPIWi
 
   // True if focus rings and accelerators are enabled for this
   // window hierarchy.
   bool mShowAccelerators;
   bool mShowFocusRings;
 
   nsCOMPtr<mozilla::dom::EventTarget> mParent;
 
-  // The TabParents that are currently registered with this top-level window.
+  // The BrowserParents that are currently registered with this top-level
+  // window.
   typedef nsTHashtable<nsRefPtrHashKey<nsIWeakReference>> WeakBrowserTable;
   WeakBrowserTable mWeakBrowsers;
 };
 
 extern already_AddRefed<mozilla::dom::EventTarget> NS_NewWindowRoot(
     nsPIDOMWindowOuter* aWindow);
 
 #endif
--- a/dom/base/nsWrapperCache.h
+++ b/dom/base/nsWrapperCache.h
@@ -12,18 +12,18 @@
 #include "js/Id.h"     // must come before js/RootingAPI.h
 #include "js/Value.h"  // must come before js/RootingAPI.h
 #include "js/RootingAPI.h"
 #include "js/TracingAPI.h"
 
 namespace mozilla {
 namespace dom {
 class ContentProcessMessageManager;
-class InProcessTabChildMessageManager;
-class TabChildMessageManager;
+class InProcessBrowserChildMessageManager;
+class BrowserChildMessageManager;
 }  // namespace dom
 }  // namespace mozilla
 class SandboxPrivate;
 class nsWindowRoot;
 
 #define NS_WRAPPERCACHE_IID                          \
   {                                                  \
     0x6f3179a1, 0x36f7, 0x4a5c, {                    \
--- a/dom/base/test/browser_force_process_selector.js
+++ b/dom/base/test/browser_force_process_selector.js
@@ -3,17 +3,17 @@
 const CONTENT_CREATED = "ipc:content-created";
 
 // Make sure that BTU.withNewTab({ ..., forceNewProcess: true }) loads
 // new tabs in their own process.
 async function spawnNewAndTest(recur, pids) {
   await BrowserTestUtils.withNewTab({ gBrowser, url: "about:blank", forceNewProcess: true },
                                     async function(browser) {
       // Make sure our new browser is in its own process.
-      let newPid = browser.frameLoader.tabParent.osPid;
+      let newPid = browser.frameLoader.remoteTab.osPid;
       ok(!pids.has(newPid), "new tab is in its own process: " + recur);
       pids.add(newPid);
 
       if (recur) {
         await spawnNewAndTest(recur - 1, pids);
       } else {
         let observer = () => {
           ok(false, "shouldn't have created a new process");
@@ -26,15 +26,15 @@ async function spawnNewAndTest(recur, pi
           // passed. Simply remove the observer.
           Services.obs.removeObserver(observer, CONTENT_CREATED);
         });
       }
   });
 }
 
 add_task(async function test() {
-  let curPid = gBrowser.selectedBrowser.frameLoader.tabParent.osPid;
+  let curPid = gBrowser.selectedBrowser.frameLoader.remoteTab.osPid;
   let maxCount = Services.prefs.getIntPref("dom.ipc.processCount");
 
   // Use at least one more tab than max processes or at least 5 to make this
   // test interesting.
   await spawnNewAndTest(Math.max(maxCount + 1, 5), new Set([ curPid ]));
 });
--- a/dom/base/test/browser_messagemanager_unload.js
+++ b/dom/base/test/browser_messagemanager_unload.js
@@ -37,17 +37,17 @@ function frameScript()
     addEventListener("pagehide", eventHandler, true);
     Services.obs.addObserver(onOuterWindowDestroyed, "outer-window-destroyed");
 
     sendAsyncMessage("Test:Ready");
   }, true);
 }
 
 const EXPECTED = [
-  // Unload events on the TabChildGlobal. These come first so that the
+  // Unload events on the BrowserChildGlobal. These come first so that the
   // docshell is available.
   ["unload", false, 2],
   ["unload", false, 2],
 
   // pagehide and unload events for the top-level page.
   ["pagehide", true, 1],
   ["pagehide", true, 3],
   ["unload", true, 1],
--- a/dom/base/test/chrome/file_bug1139964.xul
+++ b/dom/base/test/chrome/file_bug1139964.xul
@@ -35,19 +35,19 @@ https://bugzilla.mozilla.org/show_bug.cg
     ok(m.data.hasWindow, "ProcessGlobal should have Window object in the global scope!");
 
     messageManager.addMessageListener(msgName, tabListener)
     messageManager.loadFrameScript("data:,(" + mmScriptForPromiseTest.toString() + ")()", true);
   }
 
   function tabListener(m) {
     messageManager.removeMessageListener(msgName, tabListener);
-    ok(m.data.hasPromise, "TabChildGlobal should have Promise object in the global scope!");
-    ok(m.data.hasTextEncoder, "TabChildGlobal should have TextEncoder object in the global scope!");
-    ok(m.data.hasWindow, "TabChildGlobal should have Window object in the global scope!");
+    ok(m.data.hasPromise, "BrowserChildGlobal should have Promise object in the global scope!");
+    ok(m.data.hasTextEncoder, "BrowserChildGlobal should have TextEncoder object in the global scope!");
+    ok(m.data.hasWindow, "BrowserChildGlobal should have Window object in the global scope!");
 
     opener.setTimeout("done()", 0);
     window.close();
   }
 
   function run() {
     ppm.addMessageListener(msgName, processListener)
     ppm.loadProcessScript("data:,(" + mmScriptForPromiseTest.toString() + ")()", true);
--- a/dom/base/test/chrome/file_bug1209621.xul
+++ b/dom/base/test/chrome/file_bug1209621.xul
@@ -22,50 +22,50 @@ https://bugzilla.mozilla.org/show_bug.cg
   function run() {
     var docshell = window.docShell;
     ok(docshell, "Active window should have a DocShell");
     var treeOwner = docshell.treeOwner;
     ok(treeOwner, "Active docshell should have a TreeOwner!");
 
     is(treeOwner.primaryContentShell, null,
        "There shouldn't be primaryContentShell because no browser has primary=true.");
-    is(treeOwner.primaryTabParent, null,
-       "There shouldn't be primaryTabParent because no remote browser has primary=true.");
+    is(treeOwner.primaryRemoteTab, null,
+       "There shouldn't be primaryRemoteTab because no remote browser has primary=true.");
 
     var ip = document.getElementById("inprocess");
     var remote = document.getElementById("remote");
     var remote2 = document.getElementById("remote2");
 
     ip.setAttribute("primary", "true");
     ok(ip.docShell, "non-remote browser should have a DocShell.");
     is(treeOwner.primaryContentShell, ip.docShell,
        "primary browser should be the primaryContentShell.");
-    is(treeOwner.primaryTabParent, null,
-       "There shouldn't be primaryTabParent because no remote browser has primary=true.");
+    is(treeOwner.primaryRemoteTab, null,
+       "There shouldn't be primaryRemoteTab because no remote browser has primary=true.");
 
     ip.removeAttribute("primary");
     remote.setAttribute("primary", "true");
     is(treeOwner.primaryContentShell, null,
        "There shouldn't be primaryContentShell because no browser has primary=true.");
-    var tp = remote.frameLoader.tabParent;
-    ok(tp, "Remote browsers should have a TabParent.");
-    is(treeOwner.primaryTabParent, tp,
-       "primary remote browser should be the primaryTabParent.");
+    var tp = remote.frameLoader.remoteTab;
+    ok(tp, "Remote browsers should have a remoteTab.");
+    is(treeOwner.primaryRemoteTab, tp,
+       "primary remote browser should be the primaryRemoteTab.");
 
     remote.removeAttribute("primary");
     is(treeOwner.primaryContentShell, null,
        "There shouldn't be primaryContentShell because no browser has primary=true.");
-    is(treeOwner.primaryTabParent, null,
-       "There shouldn't be primaryTabParent because no remote browser has primary=true.");
+    is(treeOwner.primaryRemoteTab, null,
+       "There shouldn't be primaryRemoteTab because no remote browser has primary=true.");
 
     remote2.setAttribute("primary", "true");
-    var tp2 = remote2.frameLoader.tabParent;
-    ok(tp2, "Remote browsers should have a TabParent.");
-    is(treeOwner.primaryTabParent, tp2,
-       "primary remote browser should be the primaryTabParent.");
+    var tp2 = remote2.frameLoader.remoteTab;
+    ok(tp2, "Remote browsers should have a remoteTab.");
+    is(treeOwner.primaryRemoteTab, tp2,
+       "primary remote browser should be the primaryRemoteTab.");
     is(treeOwner.primaryContentShell, null,
        "There shouldn't be primaryContentShell because no browser has primary=true.");
 
     opener.setTimeout("done()", 0);
     window.close();
   }
 
   ]]></script>
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -1931,17 +1931,17 @@ addExternalIface('nsIWebBrowserPersistDo
 addExternalIface('nsIWebProgressListener', nativeType='nsIWebProgressListener',
                  notflattened=True)
 addExternalIface('OutputStream', nativeType='nsIOutputStream',
                  notflattened=True)
 addExternalIface('Principal', nativeType='nsIPrincipal',
                  headerFile='nsIPrincipal.h', notflattened=True)
 addExternalIface('StackFrame', nativeType='nsIStackFrame',
                  headerFile='nsIException.h', notflattened=True)
-addExternalIface('TabParent', nativeType='nsITabParent',
+addExternalIface('RemoteTab', nativeType='nsIRemoteTab',
                  notflattened=True)
 addExternalIface('URI', nativeType='nsIURI', headerFile='nsIURI.h',
                  notflattened=True)
 addExternalIface('XULCommandDispatcher', notflattened=True)
 addExternalIface('XULTemplateResult', nativeType='nsIXULTemplateResult',
                  notflattened=True)
 addExternalIface('XULTemplateRuleFilter', nativeType='nsIXULTemplateRuleFilter',
                  notflattened=True)
--- a/dom/browser-element/BrowserElementChildPreload.js
+++ b/dom/browser-element/BrowserElementChildPreload.js
@@ -128,17 +128,17 @@ BrowserElementChild.prototype = {
             .addProgressListener(this._progressListener,
                                  Ci.nsIWebProgress.NOTIFY_LOCATION |
                                  Ci.nsIWebProgress.NOTIFY_SECURITY |
                                  Ci.nsIWebProgress.NOTIFY_STATE_WINDOW);
 
     let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation);
     if (!webNavigation.sessionHistory) {
       // XXX(nika): I don't think this code should ever be hit? We should run
-      // TabChild::Init before we run this code which will perform this setup
+      // BrowserChild::Init before we run this code which will perform this setup
       // for us.
       docShell.initSessionHistory();
     }
 
     // This is necessary to get security web progress notifications.
     var securityUI = Cc["@mozilla.org/secure_browser_ui;1"]
                        .createInstance(Ci.nsISecureBrowserUI);
     securityUI.init(docShell);
@@ -168,17 +168,17 @@ BrowserElementChild.prototype = {
 
     OBSERVED_EVENTS.forEach((aTopic) => {
       Services.obs.addObserver(this, aTopic);
     });
   },
 
   /**
    * Shut down the frame's side of the browser API.  This is called when:
-   *   - our TabChildGlobal starts to die
+   *   - our BrowserChildGlobal starts to die
    *   - the content is moved to frame without the browser API
    * This is not called when the page inside |content| unloads.
    */
   destroy() {
     debug("Destroying");
     this._shuttingDown = true;
 
     BrowserElementPromptService.unmapWindowToBrowserElementChild(content);
@@ -777,17 +777,17 @@ BrowserElementChild.prototype = {
     menuData.screenX = e.screenX;
     menuData.screenY = e.screenY;
 
     // The value returned by the contextmenu sync call is true if the embedder
     // called preventDefault() on its contextmenu event.
     //
     // We call preventDefault() on our contextmenu event if the embedder called
     // preventDefault() on /its/ contextmenu event.  This way, if the embedder
-    // ignored the contextmenu event, TabChild will fire a click.
+    // ignored the contextmenu event, BrowserChild will fire a click.
     if (sendSyncMsg("contextmenu", menuData)[0]) {
       e.preventDefault();
     } else {
       this._ctxHandlers = {};
     }
   },
 
   _getSystemCtxMenuData(elem) {
--- a/dom/browser-element/BrowserElementParent.cpp
+++ b/dom/browser-element/BrowserElementParent.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "TabParent.h"
+#include "BrowserParent.h"
 
-// TabParent.h transitively includes <windows.h>, which does
+// BrowserParent.h transitively includes <windows.h>, which does
 //   #define CreateEvent CreateEventW
 // That messes up our call to EventDispatcher::CreateEvent below.
 
 #ifdef CreateEvent
 #  undef CreateEvent
 #endif
 
 #include "BrowserElementParent.h"
@@ -167,20 +167,21 @@ BrowserElementParent::DispatchOpenWindow
     }
   }
 
   return BrowserElementParent::OPEN_WINDOW_IGNORED;
 }
 
 /*static*/
 BrowserElementParent::OpenWindowResult BrowserElementParent::OpenWindowOOP(
-    TabParent* aOpenerTabParent, TabParent* aPopupTabParent,
+    BrowserParent* aOpenerBrowserParent, BrowserParent* aPopupBrowserParent,
     const nsAString& aURL, const nsAString& aName, const nsAString& aFeatures) {
   // Create an iframe owned by the same document which owns openerFrameElement.
-  nsCOMPtr<Element> openerFrameElement = aOpenerTabParent->GetOwnerElement();
+  nsCOMPtr<Element> openerFrameElement =
+      aOpenerBrowserParent->GetOwnerElement();
   NS_ENSURE_TRUE(openerFrameElement, BrowserElementParent::OPEN_WINDOW_IGNORED);
   RefPtr<HTMLIFrameElement> popupFrameElement =
       CreateIframe(openerFrameElement, aName, /* aRemote = */ true);
 
   // Normally an <iframe> element will try to create a frameLoader when the
   // page touches iframe.contentWindow or sets iframe.src.
   //
   // But in our case, we want to delay the creation of the frameLoader until
@@ -196,19 +197,19 @@ BrowserElementParent::OpenWindowResult B
       openerFrameElement, popupFrameElement, aURL, aName, aFeatures);
 
   if (opened != BrowserElementParent::OPEN_WINDOW_ADDED) {
     return opened;
   }
 
   // The popup was not blocked, so hook up the frame element and the popup tab
   // parent, and return success.
-  aPopupTabParent->SetOwnerElement(popupFrameElement);
+  aPopupBrowserParent->SetOwnerElement(popupFrameElement);
   popupFrameElement->AllowCreateFrameLoader();
-  popupFrameElement->CreateRemoteFrameLoader(aPopupTabParent);
+  popupFrameElement->CreateRemoteFrameLoader(aPopupBrowserParent);
 
   return opened;
 }
 
 /* static */
 BrowserElementParent::OpenWindowResult
 BrowserElementParent::OpenWindowInProcess(BrowsingContext* aOpenerWindow,
                                           nsIURI* aURI, const nsAString& aName,
--- a/dom/browser-element/BrowserElementParent.h
+++ b/dom/browser-element/BrowserElementParent.h
@@ -15,17 +15,17 @@
 
 class nsIDOMWindow;
 class nsIURI;
 
 namespace mozilla {
 
 namespace dom {
 class BrowsingContext;
-class TabParent;
+class BrowserParent;
 }  // namespace dom
 
 /**
  * BrowserElementParent implements a portion of the parent-process side of
  * <iframe mozbrowser>.
  *
  * Most of the parent-process side of <iframe mozbrowser> is implemented in
  * BrowserElementParent.js.  This file implements the few parts of this
@@ -69,33 +69,33 @@ class BrowserElementParent {
    *    iframe element.  This event's detail is an instance of
    *    OpenWindowEventDetail.
    *
    * 2) The embedder (the document which contains the opener iframe) can accept
    *    the window.open request by inserting event.detail.frameElement (an
    * iframe element) into the DOM somewhere.
    *
    * 3) If the embedder accepted the window.open request, we return true and
-   *    set aPopupTabParent's frame element to event.detail.frameElement.
+   *    set aPopupBrowserParent's frame element to event.detail.frameElement.
    *    Otherwise, we return false.
    *
    * @param aURL the URL the new window should load.  The empty string is
    *             allowed.
-   * @param aOpenerTabParent the TabParent whose TabChild called window.open.
-   * @param aPopupTabParent the TabParent inside which the opened window will
-   *                        live.
+   * @param aOpenerBrowserParent the BrowserParent whose BrowserChild called
+   * window.open.
+   * @param aPopupBrowserParent the BrowserParent inside which the opened window
+   * will live.
    * @return an OpenWindowresult that describes whether the embedder added the
    *         frame to a document and whether it called preventDefault to prevent
    *         the platform from handling the open request.
    */
-  static OpenWindowResult OpenWindowOOP(dom::TabParent* aOpenerTabParent,
-                                        dom::TabParent* aPopupTabParent,
-                                        const nsAString& aURL,
-                                        const nsAString& aName,
-                                        const nsAString& aFeatures);
+  static OpenWindowResult OpenWindowOOP(
+      dom::BrowserParent* aOpenerBrowserParent,
+      dom::BrowserParent* aPopupBrowserParent, const nsAString& aURL,
+      const nsAString& aName, const nsAString& aFeatures);
 
   /**
    * Handle a window.open call from an in-process <iframe mozbrowser>.
    *
    * (These parameter types are silly, but they match what our caller has in
    * hand.  Feel free to add an override, if they are inconvenient to you.)
    *
    * @param aURI the URI the new window should load.  May be null.
--- a/dom/browser-element/BrowserElementParent.jsm
+++ b/dom/browser-element/BrowserElementParent.jsm
@@ -491,17 +491,17 @@ BrowserElementParent.prototype = {
       p.reject(new this._window.DOMException(
         Cu.cloneInto(data.json.errorMsg, this._window)));
     }
   },
 
   sendMouseEvent: defineNoReturnMethod(function(type, x, y, button, clickCount, modifiers) {
     // This method used to attempt to transform from the parent
     // coordinate space to the child coordinate space, but the
-    // transform was always a no-op, because this._frameLoader.tabParent
+    // transform was always a no-op, because this._frameLoader.remoteTab
     // was null.
     this._sendAsyncMsg("send-mouse-event", {
       "type": type,
       "x": x,
       "y": y,
       "button": button,
       "clickCount": clickCount,
       "modifiers": modifiers,
--- a/dom/browser-element/mochitest/browserElement_OpenTab.js
+++ b/dom/browser-element/mochitest/browserElement_OpenTab.js
@@ -17,20 +17,20 @@ function runTest() {
   document.body.appendChild(iframe);
 
   let x = 2;
   let y = 2;
   // This test used to try to transform the coordinates from child
   // to parent coordinate space by first calling
   // iframe.getBoundingClientRect();
   // to refresh offsets and then calling
-  // var tabParent = SpecialPowers.wrap(iframe)
-  //                .frameLoader.tabParent;
-  // and calling tabParent.getChildProcessOffset(offsetX, offsetY) if
-  // tabParent was not null, but tabParent was always null.
+  // var remoteTab = SpecialPowers.wrap(iframe)
+  //                .frameLoader.remoteTab;
+  // and calling remoteTab.getChildProcessOffset(offsetX, offsetY) if
+  // remoteTab was not null, but remoteTab was always null.
 
   let sendCtrlClick = () => {
     let nsIDOMWindowUtils = SpecialPowers.Ci.nsIDOMWindowUtils;
     let mod = nsIDOMWindowUtils.MODIFIER_META |
               nsIDOMWindowUtils.MODIFIER_CONTROL;
     iframe.sendMouseEvent("mousedown", x, y, 0, 1, mod);
     iframe.sendMouseEvent("mouseup", x, y, 0, 1, mod);
   };
--- a/dom/browser-element/mochitest/browserElement_SendEvent.js
+++ b/dom/browser-element/mochitest/browserElement_SendEvent.js
@@ -14,20 +14,20 @@ function runTest() {
   iframe.setAttribute("mozbrowser", "true");
   document.body.appendChild(iframe);
   var x = 10;
   var y = 10;
   // This test used to try to transform the coordinates from child
   // to parent coordinate space by first calling
   // iframe.getBoundingClientRect();
   // to refresh offsets and then calling
-  // var tabParent = SpecialPowers.wrap(iframe)
-  //                .frameLoader.tabParent;
-  // and calling tabParent.getChildProcessOffset(offsetX, offsetY) if
-  // tabParent was not null, but tabParent was always null.
+  // var remoteTab = SpecialPowers.wrap(iframe)
+  //                .frameLoader.remoteTab;
+  // and calling remoteTab.getChildProcessOffset(offsetX, offsetY) if
+  // remoteTab was not null, but remoteTab was always null.
 
   iframe.addEventListener("mozbrowserloadend", function onloadend(e) {
     iframe.sendMouseEvent("mousedown", x, y, 0, 1, 0);
   });
 
   iframe.addEventListener("mozbrowserlocationchange", function onlocchange(e) {
     var a = document.createElement("a");
     a.href = e.detail.url;
--- a/dom/cache/Manager.cpp
+++ b/dom/cache/Manager.cpp
@@ -1857,17 +1857,17 @@ Manager::~Manager() {
   MOZ_DIAGNOSTIC_ASSERT(!mContext);
 
   nsCOMPtr<nsIThread> ioThread;
   mIOThread.swap(ioThread);
 
   // Don't spin the event loop in the destructor waiting for the thread to
   // shutdown.  Defer this to the main thread, instead.
   MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(NewRunnableMethod(
-      "nsIThread::Shutdown", ioThread, &nsIThread::Shutdown)));
+      "nsIThread::AsyncShutdown", ioThread, &nsIThread::AsyncShutdown)));
 }
 
 void Manager::Init(Manager* aOldManager) {
   NS_ASSERT_OWNINGTHREAD(Manager);
 
   RefPtr<Context> oldContext;
   if (aOldManager) {
     oldContext = aOldManager->mContext;
--- a/dom/canvas/CanvasUtils.cpp
+++ b/dom/canvas/CanvasUtils.cpp
@@ -7,17 +7,17 @@
 #include <stdarg.h>
 
 #include "nsIServiceManager.h"
 
 #include "nsIConsoleService.h"
 #include "nsICanvasRenderingContextInternal.h"
 #include "nsIHTMLCollection.h"
 #include "mozilla/dom/HTMLCanvasElement.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/EventStateManager.h"
 #include "mozilla/StaticPrefs.h"
 #include "nsIPrincipal.h"
 
 #include "nsGfxCIID.h"
 
 #include "nsTArray.h"
 
@@ -173,20 +173,20 @@ bool IsImageExtractionAllowed(Document* 
       message.AppendPrintf(" %s:%u.", scriptFile.get(), scriptLine);
     }
     nsContentUtils::LogMessageToConsole(message.get());
   }
 
   // Prompt the user (asynchronous).
   nsPIDOMWindowOuter* win = aDocument->GetWindow();
   if (XRE_IsContentProcess()) {
-    TabChild* tabChild = TabChild::GetFrom(win);
-    if (tabChild) {
-      tabChild->SendShowCanvasPermissionPrompt(topLevelDocURISpec,
-                                               isAutoBlockCanvas);
+    BrowserChild* browserChild = BrowserChild::GetFrom(win);
+    if (browserChild) {
+      browserChild->SendShowCanvasPermissionPrompt(topLevelDocURISpec,
+                                                   isAutoBlockCanvas);
     }
   } else {
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     if (obs) {
       obs->NotifyObservers(win,
                            isAutoBlockCanvas
                                ? TOPIC_CANVAS_PERMISSIONS_PROMPT_HIDE_DOORHANGER
                                : TOPIC_CANVAS_PERMISSIONS_PROMPT,
--- a/dom/chrome-webidl/ChannelWrapper.webidl
+++ b/dom/chrome-webidl/ChannelWrapper.webidl
@@ -1,15 +1,15 @@
 /* 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/. */
 
 interface LoadInfo;
 interface MozChannel;
-interface TabParent;
+interface RemoteTab;
 interface URI;
 interface nsISupports;
 
 /**
  * Load types that correspond to the external types in nsIContentPolicy.idl.
  * Please also update that IDL when updating this list.
  */
 enum MozContentPolicyType {
@@ -50,17 +50,17 @@ interface ChannelWrapper : EventTarget {
   static ChannelWrapper get(MozChannel channel);
 
   /**
    * Returns the wrapper instance for the given channel. The same wrapper is
    * always returned for a given channel.
    */
   static ChannelWrapper? getRegisteredChannel(unsigned long long aChannelId,
                                              WebExtensionPolicy extension,
-                                             TabParent? tabParent);
+                                             RemoteTab? remoteTab);
 
   /**
    * A unique ID for for the requests which remains constant throughout the
    * redirect chain.
    */
   [Constant, StoreInSlot]
   readonly attribute unsigned long long id;
 
@@ -151,19 +151,19 @@ interface ChannelWrapper : EventTarget {
    */
   boolean matches(optional MozRequestFilter filter,
                   optional WebExtensionPolicy? extension = null,
                   optional MozRequestMatchOptions options);
 
 
   /**
    * Register's this channel as traceable by the given add-on when accessed
-   * via the process of the given TabParent.
+   * via the process of the given RemoteTab.
    */
-  void registerTraceableChannel(WebExtensionPolicy extension, TabParent? tabParent);
+  void registerTraceableChannel(WebExtensionPolicy extension, RemoteTab? remoteTab);
 
   /**
    * The current HTTP status code of the request. This will be 0 if a response
    * has not yet been received, or if the request is not an HTTP request.
    */
   [Cached, Pure]
   readonly attribute unsigned long statusCode;
 
--- a/dom/chrome-webidl/WindowGlobalActors.webidl
+++ b/dom/chrome-webidl/WindowGlobalActors.webidl
@@ -1,46 +1,46 @@
 /* -*- Mode: IDL; 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/. */
 
 interface Principal;
 interface URI;
 interface nsIDocShell;
-interface TabParent;
+interface RemoteTab;
 
 [Exposed=Window, ChromeOnly]
 interface WindowGlobalParent {
   readonly attribute boolean isClosed;
   readonly attribute boolean isInProcess;
   readonly attribute CanonicalBrowsingContext browsingContext;
 
   readonly attribute boolean isCurrentGlobal;
 
   readonly attribute unsigned long long innerWindowId;
   readonly attribute unsigned long long outerWindowId;
 
   readonly attribute FrameLoader? rootFrameLoader; // Embedded (browser) only
 
   readonly attribute WindowGlobalChild? childActor; // in-process only
 
-  readonly attribute TabParent? tabParent; // out-of-process only
+  readonly attribute RemoteTab? remoteTab; // out-of-process only
 
   // Information about the currently loaded document.
   readonly attribute Principal documentPrincipal;
   readonly attribute URI? documentURI;
 
   static WindowGlobalParent? getByInnerWindowId(unsigned long long innerWindowId);
 
   [Throws]
   JSWindowActorParent getActor(DOMString name);
 
   [Throws]
-  Promise<TabParent> changeFrameRemoteness(
+  Promise<RemoteTab> changeFrameRemoteness(
     BrowsingContext? bc, DOMString remoteType,
     unsigned long long pendingSwitchId);
 };
 
 [Exposed=Window, ChromeOnly]
 interface WindowGlobalChild {
   readonly attribute boolean isClosed;
   readonly attribute boolean isInProcess;
--- a/dom/events/EventDispatcher.cpp
+++ b/dom/events/EventDispatcher.cpp
@@ -781,18 +781,18 @@ nsresult EventDispatcher::Dispatch(nsISu
       // If we can't dispatch the event to chrome, do nothing.
       EventTarget* piTarget = win ? win->GetParentTarget() : nullptr;
       if (!piTarget) {
         return NS_OK;
       }
 
       // Set the target to be the original dispatch target,
       aEvent->mTarget = target;
-      // but use chrome event handler or TabChildMessageManager for event target
-      // chain.
+      // but use chrome event handler or BrowserChildMessageManager for event
+      // target chain.
       target = piTarget;
     } else if (NS_WARN_IF(!doc)) {
       return NS_ERROR_UNEXPECTED;
     }
   }
 
 #ifdef DEBUG
   if (NS_IsMainThread() && aEvent->mMessage != eVoidEvent &&
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -19,18 +19,18 @@
 #include "mozilla/TextEditor.h"
 #include "mozilla/TextEvents.h"
 #include "mozilla/TouchEvents.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/DragEvent.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/FrameLoaderBinding.h"
 #include "mozilla/dom/MouseEventBinding.h"
-#include "mozilla/dom/TabChild.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/dom/UIEvent.h"
 #include "mozilla/dom/UIEventBinding.h"
 #include "mozilla/dom/WheelEventBinding.h"
 
 #include "ContentEventHandler.h"
 #include "IMEContentObserver.h"
 #include "WheelHandlingHelper.h"
 
@@ -56,17 +56,17 @@
 #include "nsNameSpaceManager.h"
 #include "nsIBaseWindow.h"
 #include "nsFrameSelection.h"
 #include "nsPIDOMWindow.h"
 #include "nsPIWindowRoot.h"
 #include "nsIWebNavigation.h"
 #include "nsIContentViewer.h"
 #include "nsFrameManager.h"
-#include "nsITabChild.h"
+#include "nsIBrowserChild.h"
 #include "nsPluginFrame.h"
 #include "nsMenuPopupFrame.h"
 
 #include "nsIObserverService.h"
 #include "nsIDocShell.h"
 #include "nsIMozBrowserFrame.h"
 
 #include "nsSubDocumentFrame.h"
@@ -654,19 +654,19 @@ nsresult EventStateManager::PreHandleEve
 
     case eKeyPress: {
       WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
       if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eChrome) ||
           keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) {
         // If the eKeyPress event will be sent to a remote process, this
         // process needs to wait reply from the remote process for checking if
         // preceding eKeyDown event is consumed.  If preceding eKeyDown event
-        // is consumed in the remote process, TabChild won't send the event
+        // is consumed in the remote process, BrowserChild won't send the event
         // back to this process.  So, only when this process receives a reply
-        // eKeyPress event in TabParent, we should handle accesskey in this
+        // eKeyPress event in BrowserParent, we should handle accesskey in this
         // process.
         if (IsRemoteTarget(GetFocusedContent())) {
           // However, if there is no accesskey target for the key combination,
           // we don't need to wait reply from the remote process.  Otherwise,
           // Mark the event as waiting reply from remote process and stop
           // propagation in this process.
           if (CheckIfEventMatchesAccessKey(keyEvent, aPresContext)) {
             keyEvent->StopPropagation();
@@ -1025,18 +1025,18 @@ bool EventStateManager::LookForAccessKey
           }
         }
 
         if (focusChanged && aIsTrustedEvent) {
           // If this is a child process, inform the parent that we want the
           // focus, but pass false since we don't want to change the window
           // order.
           nsIDocShell* docShell = mPresContext->GetDocShell();
-          nsCOMPtr<nsITabChild> child =
-              docShell ? docShell->GetTabChild() : nullptr;
+          nsCOMPtr<nsIBrowserChild> child =
+              docShell ? docShell->GetBrowserChild() : nullptr;
           if (child) {
             child->SendRequestFocus(false);
           }
         }
 
         return true;
       }
     }
@@ -1086,32 +1086,33 @@ void EventStateManager::GetAccessKeyLabe
 struct MOZ_STACK_CLASS AccessKeyInfo {
   WidgetKeyboardEvent* event;
   nsTArray<uint32_t>& charCodes;
 
   AccessKeyInfo(WidgetKeyboardEvent* aEvent, nsTArray<uint32_t>& aCharCodes)
       : event(aEvent), charCodes(aCharCodes) {}
 };
 
-static bool HandleAccessKeyInRemoteChild(TabParent* aTabParent, void* aArg) {
+static bool HandleAccessKeyInRemoteChild(BrowserParent* aBrowserParent,
+                                         void* aArg) {
   AccessKeyInfo* accessKeyInfo = static_cast<AccessKeyInfo*>(aArg);
 
   // Only forward accesskeys for the active tab.
   bool active;
-  aTabParent->GetDocShellIsActive(&active);
+  aBrowserParent->GetDocShellIsActive(&active);
   if (active) {
     // Even if there is no target for the accesskey in this process,
     // the event may match with a content accesskey.  If so, the keyboard
     // event should be handled with reply event for preventing double action.
     // (e.g., Alt+Shift+F on Windows may focus a content in remote and open
     // "File" menu.)
     accessKeyInfo->event->StopPropagation();
     accessKeyInfo->event->MarkAsWaitingReplyFromRemoteProcess();
-    aTabParent->HandleAccessKey(*accessKeyInfo->event,
-                                accessKeyInfo->charCodes);
+    aBrowserParent->HandleAccessKey(*accessKeyInfo->event,
+                                    accessKeyInfo->charCodes);
     return true;
   }
 
   return false;
 }
 
 bool EventStateManager::WalkESMTreeToHandleAccessKey(
     WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext,
@@ -1200,20 +1201,20 @@ bool EventStateManager::WalkESMTreeToHan
       }
     }
   }  // if end. bubble up process
 
   // If the content access key modifier is pressed, try remote children
   if (aExecute &&
       aEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent) &&
       mDocument && mDocument->GetWindow()) {
-    // If the focus is currently on a node with a TabParent, the key event
+    // If the focus is currently on a node with a BrowserParent, the key event
     // should've gotten forwarded to the child process and HandleAccessKey
     // called from there.
-    if (TabParent::GetFrom(GetFocusedContent())) {
+    if (BrowserParent::GetFrom(GetFocusedContent())) {
       // If access key may be only in remote contents, this method won't handle
       // access key synchronously.  In this case, only reply event should reach
       // here.
       MOZ_ASSERT(aEvent->IsHandledInRemoteProcess() ||
                  !aEvent->IsWaitingReplyFromRemoteProcess());
     }
     // If focus is somewhere else, then we need to check the remote children.
     // However, if the event has already been handled in a remote process,
@@ -1228,33 +1229,34 @@ bool EventStateManager::WalkESMTreeToHan
   }
 
   return false;
 }  // end of HandleAccessKey
 
 void EventStateManager::DispatchCrossProcessEvent(WidgetEvent* aEvent,
                                                   nsFrameLoader* aFrameLoader,
                                                   nsEventStatus* aStatus) {
-  TabParent* remote = TabParent::GetFrom(aFrameLoader);
+  BrowserParent* remote = BrowserParent::GetFrom(aFrameLoader);
   if (!remote) {
     return;
   }
 
   if (aEvent->mLayersId.IsValid()) {
-    TabParent* preciseRemote =
-        TabParent::GetTabParentFromLayersId(aEvent->mLayersId);
+    BrowserParent* preciseRemote =
+        BrowserParent::GetBrowserParentFromLayersId(aEvent->mLayersId);
     if (preciseRemote) {
       remote = preciseRemote;
     }
-    // else there is a race between APZ and the LayersId to TabParent mapping,
-    // so fall back to delivering the event to the topmost child process.
+    // else there is a race between APZ and the LayersId to BrowserParent
+    // mapping, so fall back to delivering the event to the topmost child
+    // process.
   } else if (aEvent->mClass == eKeyboardEventClass) {
     // APZ attaches a LayersId to hit-testable events, for keyboard events,
     // we use focus.
-    TabParent* preciseRemote = TabParent::GetFocused();
+    BrowserParent* preciseRemote = BrowserParent::GetFocused();
     if (preciseRemote) {
       remote = preciseRemote;
     }
     // else there is a race between layout and focus tracking,
     // so fall back to delivering the event to the topmost child process.
   }
 
   switch (aEvent->mClass) {
@@ -1273,51 +1275,51 @@ void EventStateManager::DispatchCrossPro
     case eTouchEventClass: {
       // Let the child process synthesize a mouse event if needed, and
       // ensure we don't synthesize one in this process.
       *aStatus = nsEventStatus_eConsumeNoDefault;
       remote->SendRealTouchEvent(*aEvent->AsTouchEvent());
       return;
     }
     case eDragEventClass: {
-      RefPtr<TabParent> tabParent = remote;
-      tabParent->Manager()->MaybeInvokeDragSession(tabParent);
+      RefPtr<BrowserParent> browserParent = remote;
+      browserParent->Manager()->MaybeInvokeDragSession(browserParent);
 
       nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
       uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
       uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE;
       nsCOMPtr<nsIPrincipal> principal;
       if (dragSession) {
         dragSession->DragEventDispatchedToChildProcess();
         dragSession->GetDragAction(&action);
         dragSession->GetTriggeringPrincipal(getter_AddRefs(principal));
         RefPtr<DataTransfer> initialDataTransfer =
             dragSession->GetDataTransfer();
         if (initialDataTransfer) {
           dropEffect = initialDataTransfer->DropEffectInt();
         }
       }
 
-      tabParent->SendRealDragEvent(*aEvent->AsDragEvent(), action, dropEffect,
-                                   IPC::Principal(principal));
+      browserParent->SendRealDragEvent(*aEvent->AsDragEvent(), action,
+                                       dropEffect, IPC::Principal(principal));
       return;
     }
     case ePluginEventClass: {
       *aStatus = nsEventStatus_eConsumeNoDefault;
       remote->SendPluginEvent(*aEvent->AsPluginEvent());
       return;
     }
     default: {
       MOZ_CRASH("Attempt to send non-whitelisted event?");
     }
   }
 }
 
 bool EventStateManager::IsRemoteTarget(nsIContent* target) {
-  return !!TabParent::GetFrom(target);
+  return !!BrowserParent::GetFrom(target);
 }
 
 bool EventStateManager::HandleCrossProcessEvent(WidgetEvent* aEvent,
                                                 nsEventStatus* aStatus) {
   if (!aEvent->CanBeSentToRemoteProcess()) {
     return false;
   }
 
@@ -2034,26 +2036,26 @@ bool EventStateManager::DoDefaultDragSta
 nsresult EventStateManager::GetContentViewer(nsIContentViewer** aCv) {
   *aCv = nullptr;
 
   nsPIDOMWindowOuter* window = mDocument->GetWindow();
   if (!window) return NS_ERROR_FAILURE;
   nsCOMPtr<nsPIDOMWindowOuter> rootWindow = window->GetPrivateRoot();
   if (!rootWindow) return NS_ERROR_FAILURE;
 
-  TabChild* tabChild = TabChild::GetFrom(rootWindow);
-  if (!tabChild) {
+  BrowserChild* browserChild = BrowserChild::GetFrom(rootWindow);
+  if (!browserChild) {
     nsIFocusManager* fm = nsFocusManager::GetFocusManager();
     if (!fm) return NS_ERROR_FAILURE;
 
     nsCOMPtr<mozIDOMWindowProxy> activeWindow;
     fm->GetActiveWindow(getter_AddRefs(activeWindow));
     if (rootWindow != activeWindow) return NS_OK;
   } else {
-    if (!tabChild->ParentIsActive()) return NS_OK;
+    if (!browserChild->ParentIsActive()) return NS_OK;
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> contentWindow =
       nsGlobalWindowOuter::Cast(rootWindow)->GetContent();
   if (!contentWindow) return NS_ERROR_FAILURE;
 
   Document* doc = contentWindow->GetDoc();
   if (!doc) return NS_ERROR_FAILURE;
@@ -2882,27 +2884,27 @@ void EventStateManager::PostHandleKeyboa
     WidgetKeyboardEvent* aKeyboardEvent, nsIFrame* aTargetFrame,
     nsEventStatus& aStatus) {
   if (aStatus == nsEventStatus_eConsumeNoDefault) {
     return;
   }
 
   if (!aKeyboardEvent->HasBeenPostedToRemoteProcess()) {
     if (aKeyboardEvent->IsWaitingReplyFromRemoteProcess()) {
-      RefPtr<TabParent> remote =
-          aTargetFrame ? TabParent::GetFrom(aTargetFrame->GetContent())
+      RefPtr<BrowserParent> remote =
+          aTargetFrame ? BrowserParent::GetFrom(aTargetFrame->GetContent())
                        : nullptr;
       if (remote) {
         // remote is null-checked above in order to let pre-existing event
         // targeting code's chrome vs. content decision override in case of
         // disagreement in order not to disrupt non-Fission e10s mode in case
         // there are still bugs in the Fission-mode code. That is, if remote
         // is nullptr, the pre-existing event targeting code has deemed this
         // event to belong to chrome rather than content.
-        TabParent* preciseRemote = TabParent::GetFocused();
+        BrowserParent* preciseRemote = BrowserParent::GetFocused();
         if (preciseRemote) {
           remote = preciseRemote;
         }
         // else there was a race between layout and focus tracking
       }
       if (remote && !remote->IsReadyToHandleInputEvents()) {
         // We need to dispatch the event to the browser element again if we were
         // waiting for the key reply but the event wasn't sent to the content
@@ -3614,26 +3616,26 @@ nsresult EventStateManager::PostHandleEv
 
   // Reset target frame to null to avoid mistargeting after reentrant event
   mCurrentTarget = nullptr;
   mCurrentTargetContent = nullptr;
 
   return ret;
 }
 
-TabParent* EventStateManager::GetCrossProcessTarget() {
-  return IMEStateManager::GetActiveTabParent();
+BrowserParent* EventStateManager::GetCrossProcessTarget() {
+  return IMEStateManager::GetActiveBrowserParent();
 }
 
 bool EventStateManager::IsTargetCrossProcess(WidgetGUIEvent* aEvent) {
   // Check to see if there is a focused, editable content in chrome,
   // in that case, do not forward IME events to content
   nsIContent* focusedContent = GetFocusedContent();
   if (focusedContent && focusedContent->IsEditable()) return false;
-  return IMEStateManager::GetActiveTabParent() != nullptr;
+  return IMEStateManager::GetActiveBrowserParent() != nullptr;
 }
 
 void EventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) {
   IMEStateManager::OnDestroyPresContext(aPresContext);
   if (mHoverContent) {
     // Bug 70855: Presentation is going away, possibly for a reframe.
     // Reset the hover state so that if we're recreating the presentation,
     // we won't have the old hover state still set in the new presentation,
@@ -5591,17 +5593,17 @@ nsresult EventStateManager::DoContentCom
   } else {
     bool canDoIt;
     rv = controller->IsCommandEnabled(cmd, &canDoIt);
     NS_ENSURE_SUCCESS(rv, rv);
     aEvent->mIsEnabled = canDoIt;
     if (canDoIt && !aEvent->mOnlyEnabledCheck) {
       switch (aEvent->mMessage) {
         case eContentCommandPasteTransferable: {
-          TabParent* remote = TabParent::GetFocused();
+          BrowserParent* remote = BrowserParent::GetFocused();
           if (remote) {
             nsCOMPtr<nsITransferable> transferable = aEvent->mTransferable;
             IPCDataTransfer ipcDataTransfer;
             nsContentUtils::TransferableToIPCTransferable(
                 transferable, &ipcDataTransfer, false, nullptr,
                 remote->Manager());
             bool isPrivateData = transferable->GetIsPrivateData();
             nsCOMPtr<nsIPrincipal> requestingPrincipal =
--- a/dom/events/EventStateManager.h
+++ b/dom/events/EventStateManager.h
@@ -40,17 +40,17 @@ class IMEContentObserver;
 class ScrollbarsForWheel;
 class WheelTransaction;
 
 namespace dom {
 class DataTransfer;
 class Document;
 class Element;
 class Selection;
-class TabParent;
+class BrowserParent;
 }  // namespace dom
 
 class OverOutElementsWrapper final : public nsISupports {
   ~OverOutElementsWrapper();
 
  public:
   OverOutElementsWrapper();
 
@@ -1045,17 +1045,17 @@ class EventStateManager : public nsSuppo
   void BeginTrackingDragGesture(nsPresContext* aPresContext,
                                 WidgetMouseEvent* aDownEvent,
                                 nsIFrame* aDownFrame);
 
   void SetGestureDownPoint(WidgetGUIEvent* aEvent);
 
   LayoutDeviceIntPoint GetEventRefPoint(WidgetEvent* aEvent) const;
 
-  friend class mozilla::dom::TabParent;
+  friend class mozilla::dom::BrowserParent;
   void BeginTrackingRemoteDragGesture(nsIContent* aContent);
   void StopTrackingDragGesture();
   void GenerateDragGesture(nsPresContext* aPresContext,
                            WidgetInputEvent* aEvent);
 
   /**
    * When starting a dnd session, UA must fire a pointercancel event and stop
    * firing the subsequent pointer events.
@@ -1107,17 +1107,17 @@ class EventStateManager : public nsSuppo
    * mCurrentTarget->GetNearestWidget().
    */
   void FillInEventFromGestureDown(WidgetMouseEvent* aEvent);
 
   MOZ_CAN_RUN_SCRIPT
   nsresult DoContentCommandEvent(WidgetContentCommandEvent* aEvent);
   nsresult DoContentCommandScrollEvent(WidgetContentCommandEvent* aEvent);
 
-  dom::TabParent* GetCrossProcessTarget();
+  dom::BrowserParent* GetCrossProcessTarget();
   bool IsTargetCrossProcess(WidgetGUIEvent* aEvent);
 
   /**
    * DispatchCrossProcessEvent() try to post aEvent to target remote process.
    * If you need to check if the event is posted to a remote process, you
    * can use aEvent->HasBeenPostedToRemoteProcess().
    */
   void DispatchCrossProcessEvent(WidgetEvent* aEvent, nsFrameLoader* aRemote,
--- a/dom/events/IMEStateManager.cpp
+++ b/dom/events/IMEStateManager.cpp
@@ -17,17 +17,17 @@
 #include "mozilla/PresShell.h"
 #include "mozilla/TextComposition.h"
 #include "mozilla/TextEvents.h"
 #include "mozilla/Unused.h"
 #include "mozilla/dom/BrowserBridgeChild.h"
 #include "mozilla/dom/HTMLFormElement.h"
 #include "mozilla/dom/HTMLTextAreaElement.h"
 #include "mozilla/dom/MouseEventBinding.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 
 #include "HTMLInputElement.h"
 #include "IMEContentObserver.h"
 
 #include "nsCOMPtr.h"
 #include "nsContentUtils.h"
 #include "nsFocusManager.h"
 #include "nsIContent.h"
@@ -124,17 +124,17 @@ static const char* GetIMEStateSetOpenNam
       return "illegal value";
   }
 }
 
 StaticRefPtr<nsIContent> IMEStateManager::sContent;
 StaticRefPtr<nsPresContext> IMEStateManager::sPresContext;
 nsIWidget* IMEStateManager::sWidget = nullptr;
 nsIWidget* IMEStateManager::sFocusedIMEWidget = nullptr;
-StaticRefPtr<TabParent> IMEStateManager::sFocusedIMETabParent;
+StaticRefPtr<BrowserParent> IMEStateManager::sFocusedIMEBrowserParent;
 nsIWidget* IMEStateManager::sActiveInputContextWidget = nullptr;
 StaticRefPtr<IMEContentObserver> IMEStateManager::sActiveIMEContentObserver;
 TextCompositionArray* IMEStateManager::sTextCompositions = nullptr;
 InputContext::Origin IMEStateManager::sOrigin = InputContext::ORIGIN_MAIN;
 InputContext IMEStateManager::sActiveChildInputContext;
 bool IMEStateManager::sInstalledMenuKeyboardListener = false;
 bool IMEStateManager::sIsGettingNewIMEState = false;
 bool IMEStateManager::sCheckForIMEUnawareWebApps = false;
@@ -166,18 +166,18 @@ void IMEStateManager::Shutdown() {
   delete sTextCompositions;
   sTextCompositions = nullptr;
   // All string instances in the global space need to be empty after XPCOM
   // shutdown.
   sActiveChildInputContext.ShutDown();
 }
 
 // static
-void IMEStateManager::OnFocusMovedBetweenBrowsers(TabParent* aBlur,
-                                                  TabParent* aFocus) {
+void IMEStateManager::OnFocusMovedBetweenBrowsers(BrowserParent* aBlur,
+                                                  BrowserParent* aFocus) {
   MOZ_ASSERT(aBlur != aFocus);
   MOZ_ASSERT(XRE_IsParentProcess());
 
   nsCOMPtr<nsIWidget> oldWidget = sWidget;
   nsCOMPtr<nsIWidget> newWidget = aFocus ? aFocus->GetWidget() : nullptr;
   // In the chrome-process case, we'll get sWidget from a PresShell later.
   sWidget = newWidget;
   if (oldWidget && sTextCompositions) {
@@ -187,67 +187,67 @@ void IMEStateManager::OnFocusMovedBetwee
       MOZ_LOG(
           sISMLog, LogLevel::Debug,
           ("  OnFocusMovedBetweenBrowsers(), requesting to commit "
            "composition to "
            "the (previous) focused widget (would request=%s)",
            GetBoolName(
                !oldWidget->IMENotificationRequestsRef().WantDuringDeactive())));
       NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, oldWidget,
-                composition->GetTabParent());
+                composition->GetBrowserParent());
     }
   }
 
   if (aBlur) {
     MOZ_LOG(sISMLog, LogLevel::Debug,
             ("  OnFocusMovedBetweenBrowsers(), notifying previous "
              "focused child process of parent process or another child process "
              "getting focus"));
     Unused << aBlur->SendStopIMEStateManagement();
   }
 
   if (sActiveIMEContentObserver) {
     DestroyIMEContentObserver();
   }
 
   if (sFocusedIMEWidget) {
-    // sFocusedIMETabParent can be null, if IME focus hasn't been
-    // taken before TabParent blur.
+    // sFocusedIMEBrowserParent can be null, if IME focus hasn't been
+    // taken before BrowserParent blur.
     // aBlur can be null when keyboard focus moves not actually
     // between tabs but an open menu is involved.
-    MOZ_ASSERT(!sFocusedIMETabParent || !aBlur ||
-               (sFocusedIMETabParent == aBlur));
+    MOZ_ASSERT(!sFocusedIMEBrowserParent || !aBlur ||
+               (sFocusedIMEBrowserParent == aBlur));
     MOZ_LOG(sISMLog, LogLevel::Debug,
             ("  OnFocusMovedBetweenBrowsers(), notifying IME of blur"));
-    NotifyIME(NOTIFY_IME_OF_BLUR, sFocusedIMEWidget, sFocusedIMETabParent);
+    NotifyIME(NOTIFY_IME_OF_BLUR, sFocusedIMEWidget, sFocusedIMEBrowserParent);
 
-    MOZ_ASSERT(!sFocusedIMETabParent);
+    MOZ_ASSERT(!sFocusedIMEBrowserParent);
     MOZ_ASSERT(!sFocusedIMEWidget);
 
   } else {
-    MOZ_ASSERT(!sFocusedIMETabParent);
+    MOZ_ASSERT(!sFocusedIMEBrowserParent);
   }
 
   // We deliberely don't null out sContent or sPresContext here. When
   // focus is in remote content, as far as layout in the chrome process
   // is concerned, the corresponding content is the top-level XUL
   // browser. Changes among out-of-process iframes don't change that,
   // so dropping the pointer to the XUL browser upon such a change
   // would break IME handling.
 }
 
 // static
 void IMEStateManager::WidgetDestroyed(nsIWidget* aWidget) {
   if (sWidget == aWidget) {
     sWidget = nullptr;
   }
   if (sFocusedIMEWidget == aWidget) {
-    if (sFocusedIMETabParent) {
-      OnFocusMovedBetweenBrowsers(sFocusedIMETabParent, nullptr);
-      MOZ_ASSERT(!sFocusedIMETabParent);
+    if (sFocusedIMEBrowserParent) {
+      OnFocusMovedBetweenBrowsers(sFocusedIMEBrowserParent, nullptr);
+      MOZ_ASSERT(!sFocusedIMEBrowserParent);
     }
     sFocusedIMEWidget = nullptr;
   }
   if (sActiveInputContextWidget == aWidget) {
     sActiveInputContextWidget = nullptr;
   }
 }
 
@@ -338,17 +338,17 @@ nsresult IMEStateManager::OnDestroyPresC
 
   DestroyIMEContentObserver();
 
   if (sWidget) {
     IMEState newState = GetNewIMEState(sPresContext, nullptr);
     InputContextAction action(InputContextAction::CAUSE_UNKNOWN,
                               InputContextAction::LOST_FOCUS);
     InputContext::Origin origin =
-        TabParent::GetFocused() ? InputContext::ORIGIN_CONTENT : sOrigin;
+        BrowserParent::GetFocused() ? InputContext::ORIGIN_CONTENT : sOrigin;
     SetIMEState(newState, nullptr, nullptr, sWidget, action, origin);
   }
   sWidget = nullptr;
   sContent = nullptr;
   sPresContext = nullptr;
   return NS_OK;
 }
 
@@ -393,17 +393,17 @@ nsresult IMEStateManager::OnRemoveConten
   DestroyIMEContentObserver();
 
   // Current IME transaction should commit
   if (sWidget) {
     IMEState newState = GetNewIMEState(sPresContext, nullptr);
     InputContextAction action(InputContextAction::CAUSE_UNKNOWN,
                               InputContextAction::LOST_FOCUS);
     InputContext::Origin origin =
-        TabParent::GetFocused() ? InputContext::ORIGIN_CONTENT : sOrigin;
+        BrowserParent::GetFocused() ? InputContext::ORIGIN_CONTENT : sOrigin;
     SetIMEState(newState, aPresContext, nullptr, sWidget, action, origin);
   }
 
   sWidget = nullptr;
   sContent = nullptr;
   sPresContext = nullptr;
 
   return NS_OK;
@@ -427,31 +427,31 @@ nsresult IMEStateManager::OnChangeFocus(
   return OnChangeFocusInternal(aPresContext, aContent, action);
 }
 
 // static
 nsresult IMEStateManager::OnChangeFocusInternal(nsPresContext* aPresContext,
                                                 nsIContent* aContent,
                                                 InputContextAction aAction) {
   bool remoteHasFocus =
-      TabParent::GetFrom(aContent) || BrowserBridgeChild::GetFrom(aContent);
+      BrowserParent::GetFrom(aContent) || BrowserBridgeChild::GetFrom(aContent);
 
   MOZ_LOG(sISMLog, LogLevel::Info,
           ("OnChangeFocusInternal(aPresContext=0x%p (available: %s), "
            "aContent=0x%p (remote: %s), aAction={ mCause=%s, "
            "mFocusChange=%s }), "
            "sPresContext=0x%p (available: %s), sContent=0x%p, "
-           "sWidget=0x%p (available: %s), TabParent::GetFocused()=0x%p, "
+           "sWidget=0x%p (available: %s), BrowserParent::GetFocused()=0x%p, "
            "sActiveIMEContentObserver=0x%p, sInstalledMenuKeyboardListener=%s",
            aPresContext, GetBoolName(CanHandleWith(aPresContext)), aContent,
            GetBoolName(remoteHasFocus), GetActionCauseName(aAction.mCause),
            GetActionFocusChangeName(aAction.mFocusChange), sPresContext.get(),
            GetBoolName(CanHandleWith(sPresContext)), sContent.get(), sWidget,
            GetBoolName(sWidget && !sWidget->Destroyed()),
-           TabParent::GetFocused(), sActiveIMEContentObserver.get(),
+           BrowserParent::GetFocused(), sActiveIMEContentObserver.get(),
            GetBoolName(sInstalledMenuKeyboardListener)));
 
   // If new aPresShell has been destroyed, this should handle the focus change
   // as nobody is getting focus.
   if (NS_WARN_IF(aPresContext && !CanHandleWith(aPresContext))) {
     MOZ_LOG(sISMLog, LogLevel::Warning,
             ("  OnChangeFocusInternal(), called with destroyed PresShell, "
              "handling this call as nobody getting focus"));
@@ -481,17 +481,17 @@ nsresult IMEStateManager::OnChangeFocusI
       // We need to clean up only the oldWidget's composition state here.
       if (aPresContext ||
           !oldWidget->IMENotificationRequestsRef().WantDuringDeactive()) {
         MOZ_LOG(
             sISMLog, LogLevel::Info,
             ("  OnChangeFocusInternal(), requesting to commit composition to "
              "the (previous) focused widget"));
         NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, oldWidget,
-                  composition->GetTabParent());
+                  composition->GetBrowserParent());
       }
     }
   }
 
   if (sActiveIMEContentObserver) {
     MOZ_ASSERT(!remoteHasFocus,
                "IMEContentObserver should have been destroyed by "
                "OnFocusMovedBetweenBrowsers.");
@@ -600,17 +600,17 @@ nsresult IMEStateManager::OnChangeFocusI
         return NS_OK;
       }
       aAction.mFocusChange = InputContextAction::FOCUS_NOT_CHANGED;
 
       // Even if focus isn't changing actually, we should commit current
       // composition here since the IME state is changing.
       if (sPresContext && oldWidget && !focusActuallyChanging) {
         NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, oldWidget,
-                  sFocusedIMETabParent);
+                  sFocusedIMEBrowserParent);
       }
     } else if (aAction.mFocusChange == InputContextAction::FOCUS_NOT_CHANGED) {
       // If aContent isn't null or aContent is null but editable, somebody gets
       // focus.
       bool gotFocus = aContent || (newState.mEnabled == IMEState::ENABLED);
       aAction.mFocusChange = gotFocus ? InputContextAction::GOT_FOCUS
                                       : InputContextAction::LOST_FOCUS;
     }
@@ -649,37 +649,37 @@ nsresult IMEStateManager::OnChangeFocusI
   return NS_OK;
 }
 
 // static
 void IMEStateManager::OnInstalledMenuKeyboardListener(bool aInstalling) {
   MOZ_LOG(
       sISMLog, LogLevel::Info,
       ("OnInstalledMenuKeyboardListener(aInstalling=%s), "
-       "sInstalledMenuKeyboardListener=%s, TabParent::GetFocused()=0x%p, "
+       "sInstalledMenuKeyboardListener=%s, BrowserParent::GetFocused()=0x%p, "
        "sActiveChildInputContext={ mIMEState={ mEnabled=%s, mOpen=%s }, "
        "mHTMLInputType=\"%s\", mHTMLInputInputmode=\"%s\", mActionHint=\"%s\", "
        "mInPrivateBrowsing=%s }",
        GetBoolName(aInstalling), GetBoolName(sInstalledMenuKeyboardListener),
-       TabParent::GetFocused(),
+       BrowserParent::GetFocused(),
        GetIMEStateEnabledName(sActiveChildInputContext.mIMEState.mEnabled),
        GetIMEStateSetOpenName(sActiveChildInputContext.mIMEState.mOpen),
        NS_ConvertUTF16toUTF8(sActiveChildInputContext.mHTMLInputType).get(),
        NS_ConvertUTF16toUTF8(sActiveChildInputContext.mHTMLInputInputmode)
            .get(),
        NS_ConvertUTF16toUTF8(sActiveChildInputContext.mActionHint).get(),
        GetBoolName(sActiveChildInputContext.mInPrivateBrowsing)));
 
   sInstalledMenuKeyboardListener = aInstalling;
 
   InputContextAction action(InputContextAction::CAUSE_UNKNOWN,
                             aInstalling
                                 ? InputContextAction::MENU_GOT_PSEUDO_FOCUS
                                 : InputContextAction::MENU_LOST_PSEUDO_FOCUS);
-  TabParent* focused = TabParent::GetFocused();
+  BrowserParent* focused = BrowserParent::GetFocused();
   if (focused) {
     if (aInstalling) {
       OnFocusMovedBetweenBrowsers(focused, nullptr);
     } else {
       OnFocusMovedBetweenBrowsers(nullptr, focused);
     }
   }
   OnChangeFocusInternal(sPresContext, sContent, action);
@@ -984,17 +984,17 @@ void IMEStateManager::UpdateIMEState(con
     MOZ_LOG(
         sISMLog, LogLevel::Error,
         ("  UpdateIMEState(), widget has gone during getting input context"));
     return;
   }
 
   if (updateIMEState) {
     // commit current composition before modifying IME state.
-    NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, widget, sFocusedIMETabParent);
+    NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, widget, sFocusedIMEBrowserParent);
     if (NS_WARN_IF(widget->Destroyed())) {
       MOZ_LOG(sISMLog, LogLevel::Error,
               ("  UpdateIMEState(), widget has gone during committing "
                "composition"));
       return;
     }
   }
 
@@ -1110,39 +1110,40 @@ void IMEStateManager::ResetActiveChildIn
 
 // static
 bool IMEStateManager::HasActiveChildSetInputContext() {
   return sActiveChildInputContext.mIMEState.mEnabled != IMEState::UNKNOWN;
 }
 
 // static
 void IMEStateManager::SetInputContextForChildProcess(
-    TabParent* aTabParent, const InputContext& aInputContext,
+    BrowserParent* aBrowserParent, const InputContext& aInputContext,
     const InputContextAction& aAction) {
   MOZ_LOG(
       sISMLog, LogLevel::Info,
-      ("SetInputContextForChildProcess(aTabParent=0x%p, "
+      ("SetInputContextForChildProcess(aBrowserParent=0x%p, "
        "aInputContext={ mIMEState={ mEnabled=%s, mOpen=%s }, "
        "mHTMLInputType=\"%s\", mHTMLInputInputmode=\"%s\", mActionHint=\"%s\", "
        "mInPrivateBrowsing=%s }, aAction={ mCause=%s, mAction=%s }), "
        "sPresContext=0x%p (available: %s), sWidget=0x%p (available: %s), "
-       "TabParent::GetFocused()=0x%p, sInstalledMenuKeyboardListener=%s",
-       aTabParent, GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
+       "BrowserParent::GetFocused()=0x%p, sInstalledMenuKeyboardListener=%s",
+       aBrowserParent, GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
        GetIMEStateSetOpenName(aInputContext.mIMEState.mOpen),
        NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputType).get(),
        NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputInputmode).get(),
        NS_ConvertUTF16toUTF8(aInputContext.mActionHint).get(),
        GetBoolName(aInputContext.mInPrivateBrowsing),
        GetActionCauseName(aAction.mCause),
        GetActionFocusChangeName(aAction.mFocusChange), sPresContext.get(),
        GetBoolName(CanHandleWith(sPresContext)), sWidget,
-       GetBoolName(sWidget && !sWidget->Destroyed()), TabParent::GetFocused(),
+       GetBoolName(sWidget && !sWidget->Destroyed()),
+       BrowserParent::GetFocused(),
        GetBoolName(sInstalledMenuKeyboardListener)));
 
-  if (aTabParent != TabParent::GetFocused()) {
+  if (aBrowserParent != BrowserParent::GetFocused()) {
     MOZ_LOG(sISMLog, LogLevel::Error,
             ("  SetInputContextForChildProcess(), FAILED, "
              "because non-focused tab parent tries to set input context"));
     return;
   }
 
   if (NS_WARN_IF(!CanHandleWith(sPresContext))) {
     MOZ_LOG(sISMLog, LogLevel::Error,
@@ -1299,25 +1300,26 @@ static void GetActionHint(nsIContent& aC
 }
 
 // static
 void IMEStateManager::SetIMEState(const IMEState& aState,
                                   nsPresContext* aPresContext,
                                   nsIContent* aContent, nsIWidget* aWidget,
                                   InputContextAction aAction,
                                   InputContext::Origin aOrigin) {
-  MOZ_LOG(sISMLog, LogLevel::Info,
-          ("SetIMEState(aState={ mEnabled=%s, mOpen=%s }, "
-           "aContent=0x%p (TabParent=0x%p), aWidget=0x%p, aAction={ mCause=%s, "
-           "mFocusChange=%s }, aOrigin=%s)",
-           GetIMEStateEnabledName(aState.mEnabled),
-           GetIMEStateSetOpenName(aState.mOpen), aContent,
-           TabParent::GetFrom(aContent), aWidget,
-           GetActionCauseName(aAction.mCause),
-           GetActionFocusChangeName(aAction.mFocusChange), ToChar(aOrigin)));
+  MOZ_LOG(
+      sISMLog, LogLevel::Info,
+      ("SetIMEState(aState={ mEnabled=%s, mOpen=%s }, "
+       "aContent=0x%p (BrowserParent=0x%p), aWidget=0x%p, aAction={ mCause=%s, "
+       "mFocusChange=%s }, aOrigin=%s)",
+       GetIMEStateEnabledName(aState.mEnabled),
+       GetIMEStateSetOpenName(aState.mOpen), aContent,
+       BrowserParent::GetFrom(aContent), aWidget,
+       GetActionCauseName(aAction.mCause),
+       GetActionFocusChangeName(aAction.mFocusChange), ToChar(aOrigin)));
 
   NS_ENSURE_TRUE_VOID(aWidget);
 
   InputContext context;
   context.mIMEState = aState;
   context.mOrigin = aOrigin;
   context.mMayBeIMEUnaware = context.mIMEState.IsEditable() &&
                              sCheckForIMEUnawareWebApps &&
@@ -1385,31 +1387,32 @@ void IMEStateManager::SetIMEState(const 
 
   SetInputContext(aWidget, context, aAction);
 }
 
 // static
 void IMEStateManager::SetInputContext(nsIWidget* aWidget,
                                       const InputContext& aInputContext,
                                       const InputContextAction& aAction) {
-  MOZ_LOG(sISMLog, LogLevel::Info,
-          ("SetInputContext(aWidget=0x%p, aInputContext={ "
-           "mIMEState={ mEnabled=%s, mOpen=%s }, mHTMLInputType=\"%s\", "
-           "mHTMLInputInputmode=\"%s\", mActionHint=\"%s\", "
-           "mInPrivateBrowsing=%s }, "
-           "aAction={ mCause=%s, mAction=%s }), TabParent::GetFocused()=0x%p",
-           aWidget, GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
-           GetIMEStateSetOpenName(aInputContext.mIMEState.mOpen),
-           NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputType).get(),
-           NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputInputmode).get(),
-           NS_ConvertUTF16toUTF8(aInputContext.mActionHint).get(),
-           GetBoolName(aInputContext.mInPrivateBrowsing),
-           GetActionCauseName(aAction.mCause),
-           GetActionFocusChangeName(aAction.mFocusChange),
-           TabParent::GetFocused()));
+  MOZ_LOG(
+      sISMLog, LogLevel::Info,
+      ("SetInputContext(aWidget=0x%p, aInputContext={ "
+       "mIMEState={ mEnabled=%s, mOpen=%s }, mHTMLInputType=\"%s\", "
+       "mHTMLInputInputmode=\"%s\", mActionHint=\"%s\", "
+       "mInPrivateBrowsing=%s }, "
+       "aAction={ mCause=%s, mAction=%s }), BrowserParent::GetFocused()=0x%p",
+       aWidget, GetIMEStateEnabledName(aInputContext.mIMEState.mEnabled),
+       GetIMEStateSetOpenName(aInputContext.mIMEState.mOpen),
+       NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputType).get(),
+       NS_ConvertUTF16toUTF8(aInputContext.mHTMLInputInputmode).get(),
+       NS_ConvertUTF16toUTF8(aInputContext.mActionHint).get(),
+       GetBoolName(aInputContext.mInPrivateBrowsing),
+       GetActionCauseName(aAction.mCause),
+       GetActionFocusChangeName(aAction.mFocusChange),
+       BrowserParent::GetFocused()));
 
   MOZ_RELEASE_ASSERT(aWidget);
 
   nsCOMPtr<nsIWidget> widget(aWidget);
   widget->SetInputContext(aInputContext, aAction);
   sActiveInputContextWidget = widget;
 }
 
@@ -1419,39 +1422,39 @@ void IMEStateManager::EnsureTextComposit
     return;
   }
   sTextCompositions = new TextCompositionArray();
 }
 
 // static
 void IMEStateManager::DispatchCompositionEvent(
     nsINode* aEventTargetNode, nsPresContext* aPresContext,
-    TabParent* aTabParent, WidgetCompositionEvent* aCompositionEvent,
+    BrowserParent* aBrowserParent, WidgetCompositionEvent* aCompositionEvent,
     nsEventStatus* aStatus, EventDispatchingCallback* aCallBack,
     bool aIsSynthesized) {
   MOZ_LOG(
       sISMLog, LogLevel::Info,
       ("DispatchCompositionEvent(aNode=0x%p, "
        "aPresContext=0x%p, aCompositionEvent={ mMessage=%s, "
        "mNativeIMEContext={ mRawNativeIMEContext=0x%" PRIXPTR ", "
        "mOriginProcessID=0x%" PRIX64 " }, mWidget(0x%p)={ "
        "GetNativeIMEContext()={ mRawNativeIMEContext=0x%" PRIXPTR ", "
        "mOriginProcessID=0x%" PRIX64 " }, Destroyed()=%s }, "
        "mFlags={ mIsTrusted=%s, mPropagationStopped=%s } }, "
-       "aIsSynthesized=%s), tabParent=%p",
+       "aIsSynthesized=%s), browserParent=%p",
        aEventTargetNode, aPresContext, ToChar(aCompositionEvent->mMessage),
        aCompositionEvent->mNativeIMEContext.mRawNativeIMEContext,
        aCompositionEvent->mNativeIMEContext.mOriginProcessID,
        aCompositionEvent->mWidget.get(),
        aCompositionEvent->mWidget->GetNativeIMEContext().mRawNativeIMEContext,
        aCompositionEvent->mWidget->GetNativeIMEContext().mOriginProcessID,
        GetBoolName(aCompositionEvent->mWidget->Destroyed()),
        GetBoolName(aCompositionEvent->mFlags.mIsTrusted),
        GetBoolName(aCompositionEvent->mFlags.mPropagationStopped),
-       GetBoolName(aIsSynthesized), aTabParent));
+       GetBoolName(aIsSynthesized), aBrowserParent));
 
   if (!aCompositionEvent->IsTrusted() ||
       aCompositionEvent->PropagationStopped()) {
     return;
   }
 
   MOZ_ASSERT(aCompositionEvent->mMessage != eCompositionUpdate,
              "compositionupdate event shouldn't be dispatched manually");
@@ -1466,17 +1469,17 @@ void IMEStateManager::DispatchCompositio
     if (NS_WARN_IF(aIsSynthesized)) {
       return;
     }
     MOZ_LOG(sISMLog, LogLevel::Debug,
             ("  DispatchCompositionEvent(), "
              "adding new TextComposition to the array"));
     MOZ_ASSERT(aCompositionEvent->mMessage == eCompositionStart);
     composition = new TextComposition(aPresContext, aEventTargetNode,
-                                      aTabParent, aCompositionEvent);
+                                      aBrowserParent, aCompositionEvent);
     sTextCompositions->AppendElement(composition);
   }
 #ifdef DEBUG
   else {
     MOZ_ASSERT(aCompositionEvent->mMessage != eCompositionStart);
   }
 #endif  // #ifdef DEBUG
 
@@ -1528,42 +1531,43 @@ nsIContent* IMEStateManager::GetRootCont
 }
 
 // static
 void IMEStateManager::HandleSelectionEvent(
     nsPresContext* aPresContext, nsIContent* aEventTargetContent,
     WidgetSelectionEvent* aSelectionEvent) {
   nsIContent* eventTargetContent =
       aEventTargetContent ? aEventTargetContent : GetRootContent(aPresContext);
-  RefPtr<TabParent> tabParent =
-      eventTargetContent ? TabParent::GetFrom(eventTargetContent) : nullptr;
+  RefPtr<BrowserParent> browserParent =
+      eventTargetContent ? BrowserParent::GetFrom(eventTargetContent) : nullptr;
 
-  MOZ_LOG(sISMLog, LogLevel::Info,
-          ("HandleSelectionEvent(aPresContext=0x%p, "
-           "aEventTargetContent=0x%p, aSelectionEvent={ mMessage=%s, "
-           "mFlags={ mIsTrusted=%s } }), tabParent=%p",
-           aPresContext, aEventTargetContent, ToChar(aSelectionEvent->mMessage),
-           GetBoolName(aSelectionEvent->mFlags.mIsTrusted), tabParent.get()));
+  MOZ_LOG(
+      sISMLog, LogLevel::Info,
+      ("HandleSelectionEvent(aPresContext=0x%p, "
+       "aEventTargetContent=0x%p, aSelectionEvent={ mMessage=%s, "
+       "mFlags={ mIsTrusted=%s } }), browserParent=%p",
+       aPresContext, aEventTargetContent, ToChar(aSelectionEvent->mMessage),
+       GetBoolName(aSelectionEvent->mFlags.mIsTrusted), browserParent.get()));
 
   if (!aSelectionEvent->IsTrusted()) {
     return;
   }
 
   RefPtr<TextComposition> composition =
       sTextCompositions
           ? sTextCompositions->GetCompositionFor(aSelectionEvent->mWidget)
           : nullptr;
   if (composition) {
     // When there is a composition, TextComposition should guarantee that the
     // selection event will be handled in same target as composition events.
     composition->HandleSelectionEvent(aSelectionEvent);
   } else {
     // When there is no composition, the selection event should be handled
-    // in the aPresContext or tabParent.
-    TextComposition::HandleSelectionEvent(aPresContext, tabParent,
+    // in the aPresContext or browserParent.
+    TextComposition::HandleSelectionEvent(aPresContext, browserParent,
                                           aSelectionEvent);
   }
 }
 
 // static
 void IMEStateManager::OnCompositionEventDiscarded(
     WidgetCompositionEvent* aCompositionEvent) {
   // Note that this method is never called for synthesized events for emulating
@@ -1608,87 +1612,88 @@ void IMEStateManager::OnCompositionEvent
              "TextComposition instance for the widget has already gone"));
     return;
   }
   composition->OnCompositionEventDiscarded(aCompositionEvent);
 }
 
 // static
 nsresult IMEStateManager::NotifyIME(IMEMessage aMessage, nsIWidget* aWidget,
-                                    TabParent* aTabParent) {
+                                    BrowserParent* aBrowserParent) {
   return IMEStateManager::NotifyIME(IMENotification(aMessage), aWidget,
-                                    aTabParent);
+                                    aBrowserParent);
 }
 
 // static
 nsresult IMEStateManager::NotifyIME(const IMENotification& aNotification,
-                                    nsIWidget* aWidget, TabParent* aTabParent) {
-  MOZ_LOG(
-      sISMLog, LogLevel::Info,
-      ("NotifyIME(aNotification={ mMessage=%s }, "
-       "aWidget=0x%p, aTabParent=0x%p), sFocusedIMEWidget=0x%p, "
-       "TabParent::GetFocused()=0x%p, sFocusedIMETabParent=0x%p, "
-       "aTabParent == TabParent::GetFocused()=%s, "
-       "aTabParent == sFocusedIMETabParent=%s",
-       ToChar(aNotification.mMessage), aWidget, aTabParent, sFocusedIMEWidget,
-       TabParent::GetFocused(), sFocusedIMETabParent.get(),
-       GetBoolName(aTabParent == TabParent::GetFocused()),
-       GetBoolName(aTabParent == sFocusedIMETabParent)));
+                                    nsIWidget* aWidget,
+                                    BrowserParent* aBrowserParent) {
+  MOZ_LOG(sISMLog, LogLevel::Info,
+          ("NotifyIME(aNotification={ mMessage=%s }, "
+           "aWidget=0x%p, aBrowserParent=0x%p), sFocusedIMEWidget=0x%p, "
+           "BrowserParent::GetFocused()=0x%p, sFocusedIMEBrowserParent=0x%p, "
+           "aBrowserParent == BrowserParent::GetFocused()=%s, "
+           "aBrowserParent == sFocusedIMEBrowserParent=%s",
+           ToChar(aNotification.mMessage), aWidget, aBrowserParent,
+           sFocusedIMEWidget, BrowserParent::GetFocused(),
+           sFocusedIMEBrowserParent.get(),
+           GetBoolName(aBrowserParent == BrowserParent::GetFocused()),
+           GetBoolName(aBrowserParent == sFocusedIMEBrowserParent)));
 
   if (NS_WARN_IF(!aWidget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
             ("  NotifyIME(), FAILED due to no widget"));
     return NS_ERROR_INVALID_ARG;
   }
 
   switch (aNotification.mMessage) {
     case NOTIFY_IME_OF_FOCUS: {
       // If focus notification comes from a remote browser which already lost
       // focus, we shouldn't accept the focus notification.  Then, following
       // notifications from the process will be ignored.
-      if (aTabParent != TabParent::GetFocused()) {
+      if (aBrowserParent != BrowserParent::GetFocused()) {
         MOZ_LOG(sISMLog, LogLevel::Warning,
                 ("  NotifyIME(), WARNING, the received focus notification is "
-                 "ignored, because its associated TabParent did not match"
-                 "the focused TabParent."));
+                 "ignored, because its associated BrowserParent did not match"
+                 "the focused BrowserParent."));
         return NS_OK;
       }
       // If IME focus is already set, first blur the currently-focused
       // IME widget
       if (sFocusedIMEWidget) {
         // XXX Why don't we first request the previously-focused IME
         // widget to commit the composition?
         MOZ_ASSERT(
-            sFocusedIMETabParent || aTabParent,
+            sFocusedIMEBrowserParent || aBrowserParent,
             "This case shouldn't be caused by focus move in this process");
         MOZ_LOG(sISMLog, LogLevel::Warning,
                 ("  NotifyIME(), WARNING, received focus notification with ")
                  "non-null sFocusedIMEWidget. How come "
                  "OnFocusMovedBetweenBrowsers did not blur it already?");
         nsCOMPtr<nsIWidget> focusedIMEWidget(sFocusedIMEWidget);
         sFocusedIMEWidget = nullptr;
-        sFocusedIMETabParent = nullptr;
+        sFocusedIMEBrowserParent = nullptr;
         focusedIMEWidget->NotifyIME(IMENotification(NOTIFY_IME_OF_BLUR));
       }
 #ifdef DEBUG
-      if (aTabParent) {
-        nsCOMPtr<nsIWidget> tabParentWidget = aTabParent->GetWidget();
-        MOZ_ASSERT(tabParentWidget == aWidget);
+      if (aBrowserParent) {
+        nsCOMPtr<nsIWidget> browserParentWidget = aBrowserParent->GetWidget();
+        MOZ_ASSERT(browserParentWidget == aWidget);
       }
 #endif
-      sFocusedIMETabParent = aTabParent;
+      sFocusedIMEBrowserParent = aBrowserParent;
       sFocusedIMEWidget = aWidget;
       nsCOMPtr<nsIWidget> widget(aWidget);
       MOZ_LOG(
           sISMLog, LogLevel::Info,
           ("  NotifyIME(), about to call widget->NotifyIME() for IME focus"));
       return widget->NotifyIME(aNotification);
     }
     case NOTIFY_IME_OF_BLUR: {
-      if (aTabParent != sFocusedIMETabParent) {
+      if (aBrowserParent != sFocusedIMEBrowserParent) {
         MOZ_LOG(sISMLog, LogLevel::Warning,
                 ("  NotifyIME(), WARNING, the received blur notification is "
                  "ignored "
                  "because it's not from current focused IME browser"));
         return NS_OK;
       }
       if (!sFocusedIMEWidget) {
         MOZ_LOG(
@@ -1701,25 +1706,25 @@ nsresult IMEStateManager::NotifyIME(cons
         MOZ_LOG(sISMLog, LogLevel::Warning,
                 ("  NotifyIME(), WARNING, the received blur notification is "
                  "ignored "
                  "because it's not for current focused IME widget"));
         return NS_OK;
       }
       nsCOMPtr<nsIWidget> focusedIMEWidget(sFocusedIMEWidget);
       sFocusedIMEWidget = nullptr;
-      sFocusedIMETabParent = nullptr;
+      sFocusedIMEBrowserParent = nullptr;
       return focusedIMEWidget->NotifyIME(IMENotification(NOTIFY_IME_OF_BLUR));
     }
     case NOTIFY_IME_OF_SELECTION_CHANGE:
     case NOTIFY_IME_OF_TEXT_CHANGE:
     case NOTIFY_IME_OF_POSITION_CHANGE:
     case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
     case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED: {
-      if (aTabParent != sFocusedIMETabParent) {
+      if (aBrowserParent != sFocusedIMEBrowserParent) {
         MOZ_LOG(
             sISMLog, LogLevel::Warning,
             ("  NotifyIME(), WARNING, the received content change notification "
              "is ignored because it's not from current focused IME browser"));
         return NS_OK;
       }
       if (!sFocusedIMEWidget) {
         MOZ_LOG(
@@ -1755,17 +1760,17 @@ nsresult IMEStateManager::NotifyIME(cons
       sTextCompositions->GetCompositionFor(aWidget);
   if (!composition) {
     MOZ_LOG(sISMLog, LogLevel::Info,
             ("  NotifyIME(), the request to IME is ignored because "
              "there is no active composition"));
     return NS_OK;
   }
 
-  if (aTabParent != composition->GetTabParent()) {
+  if (aBrowserParent != composition->GetBrowserParent()) {
     MOZ_LOG(
         sISMLog, LogLevel::Warning,
         ("  NotifyIME(), WARNING, the request to IME is ignored because "
          "it does not come from the remote browser which has the composition "
          "on aWidget"));
     return NS_OK;
   }
 
@@ -1780,33 +1785,33 @@ nsresult IMEStateManager::NotifyIME(cons
   MOZ_CRASH(
       "Failed to handle the notification for non-synthesized composition");
   return NS_ERROR_FAILURE;
 }
 
 // static
 nsresult IMEStateManager::NotifyIME(IMEMessage aMessage,
                                     nsPresContext* aPresContext,
-                                    TabParent* aTabParent) {
+                                    BrowserParent* aBrowserParent) {
   MOZ_LOG(sISMLog, LogLevel::Info,
-          ("NotifyIME(aMessage=%s, aPresContext=0x%p, aTabParent=0x%p)",
-           ToChar(aMessage), aPresContext, aTabParent));
+          ("NotifyIME(aMessage=%s, aPresContext=0x%p, aBrowserParent=0x%p)",
+           ToChar(aMessage), aPresContext, aBrowserParent));
 
   if (NS_WARN_IF(!CanHandleWith(aPresContext))) {
     return NS_ERROR_INVALID_ARG;
   }
 
   nsIWidget* widget = aPresContext->GetRootWidget();
   if (NS_WARN_IF(!widget)) {
     MOZ_LOG(sISMLog, LogLevel::Error,
             ("  NotifyIME(), FAILED due to no widget for the "
              "nsPresContext"));
     return NS_ERROR_NOT_AVAILABLE;
   }
-  return NotifyIME(aMessage, widget, aTabParent);
+  return NotifyIME(aMessage, widget, aBrowserParent);
 }
 
 // static
 bool IMEStateManager::IsEditable(nsINode* node) {
   if (node->IsEditable()) {
     return true;
   }
   // |node| might be readwrite (for example, a text control)
--- a/dom/events/IMEStateManager.h
+++ b/dom/events/IMEStateManager.h
@@ -4,17 +4,17 @@
  * 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/. */
 
 #ifndef mozilla_IMEStateManager_h_
 #define mozilla_IMEStateManager_h_
 
 #include "mozilla/EventForwards.h"
 #include "mozilla/StaticPtr.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "nsIWidget.h"
 
 class nsIContent;
 class nsINode;
 class nsPresContext;
 
 namespace mozilla {
 
@@ -30,63 +30,66 @@ class Selection;
 
 /**
  * IMEStateManager manages InputContext (e.g., active editor type, IME enabled
  * state and IME open state) of nsIWidget instances, manages IMEContentObserver
  * and provides useful API for IME.
  */
 
 class IMEStateManager {
-  typedef dom::TabParent TabParent;
+  typedef dom::BrowserParent BrowserParent;
   typedef widget::IMEMessage IMEMessage;
   typedef widget::IMENotification IMENotification;
   typedef widget::IMEState IMEState;
   typedef widget::InputContext InputContext;
   typedef widget::InputContextAction InputContextAction;
 
  public:
   static void Init();
   static void Shutdown();
 
   /**
-   * GetActiveTabParent() returns a pointer to a TabParent instance which is
-   * managed by the focused content (sContent).  If the focused content isn't
-   * managing another process, this returns nullptr.
+   * GetActiveBrowserParent() returns a pointer to a BrowserParent instance
+   * which is managed by the focused content (sContent).  If the focused content
+   * isn't managing another process, this returns nullptr.
    */
-  static TabParent* GetActiveTabParent() {
+  static BrowserParent* GetActiveBrowserParent() {
     // If menu has pseudo focus, we should ignore active child process.
     if (sInstalledMenuKeyboardListener) {
       return nullptr;
     }
-    return TabParent::GetFocused();
+    return BrowserParent::GetFocused();
   }
 
   /**
-   * DoesTabParentHaveIMEFocus() returns true when aTabParent has IME focus,
-   * i.e., the TabParent sent "focus" notification but not yet sends "blur".
-   * Note that this doesn't check if the remote processes are same because
-   * if another TabParent has focus, committing composition causes firing
-   * composition events in different TabParent.  (Anyway, such case shouldn't
-   * occur.)
+   * DoesBrowserParentHaveIMEFocus() returns true when aBrowserParent has IME
+   * focus, i.e., the BrowserParent sent "focus" notification but not yet sends
+   * "blur". Note that this doesn't check if the remote processes are same
+   * because if another BrowserParent has focus, committing composition causes
+   * firing composition events in different BrowserParent.  (Anyway, such case
+   * shouldn't occur.)
    */
-  static bool DoesTabParentHaveIMEFocus(const TabParent* aTabParent) {
-    MOZ_ASSERT(aTabParent);
-    return sFocusedIMETabParent == aTabParent;
+  static bool DoesBrowserParentHaveIMEFocus(
+      const BrowserParent* aBrowserParent) {
+    MOZ_ASSERT(aBrowserParent);
+    return sFocusedIMEBrowserParent == aBrowserParent;
   }
 
   /**
-   * OnTabParentDestroying() is called when aTabParent is being destroyed.
+   * OnBrowserParentDestroying() is called when aBrowserParent is being
+   * destroyed.
    */
-  static void OnTabParentDestroying(TabParent* aTabParent);
+  static void OnBrowserParentDestroying(BrowserParent* aBrowserParent);
 
   /**
    * Focus moved between browsers from aBlur to aFocus. (nullptr means the
    * chrome process.)
    */
-  static void OnFocusMovedBetweenBrowsers(TabParent* aBlur, TabParent* aFocus);
+  static void OnFocusMovedBetweenBrowsers(BrowserParent* aBlur,
+                                          BrowserParent* aFocus);
 
   /**
    * Called when aWidget is being deleted.
    */
   static void WidgetDestroyed(nsIWidget* aWidget);
 
   /**
    * GetWidgetForActiveInputContext() returns a widget which IMEStateManager
@@ -97,20 +100,20 @@ class IMEStateManager {
    * IMEStateManager may have already changed shared input context via the
    * widget.
    */
   static nsIWidget* GetWidgetForActiveInputContext() {
     return sActiveInputContextWidget;
   }
 
   /**
-   * SetIMEContextForChildProcess() is called when aTabParent receives
+   * SetIMEContextForChildProcess() is called when aBrowserParent receives
    * SetInputContext() from the remote process.
    */
-  static void SetInputContextForChildProcess(TabParent* aTabParent,
+  static void SetInputContextForChildProcess(BrowserParent* aBrowserParent,
                                              const InputContext& aInputContext,
                                              const InputContextAction& aAction);
 
   /**
    * StopIMEStateManagement() is called when the process should stop managing
    * IME state.
    */
   static void StopIMEStateManagement();
@@ -198,17 +201,17 @@ class IMEStateManager {
   /**
    * All composition events must be dispatched via DispatchCompositionEvent()
    * for storing the composition target and ensuring a set of composition
    * events must be fired the stored target.  If the stored composition event
    * target is destroying, this removes the stored composition automatically.
    */
   static void DispatchCompositionEvent(
       nsINode* aEventTargetNode, nsPresContext* aPresContext,
-      TabParent* aTabParent, WidgetCompositionEvent* aCompositionEvent,
+      BrowserParent* aBrowserParent, WidgetCompositionEvent* aCompositionEvent,
       nsEventStatus* aStatus, EventDispatchingCallback* aCallBack,
       bool aIsSynthesized = false);
 
   /**
    * All selection events must be handled via HandleSelectionEvent()
    * because they must be handled by same target as composition events when
    * there is a composition.
    */
@@ -245,21 +248,21 @@ class IMEStateManager {
       nsPresContext* aPresContext);
 
   /**
    * Send a notification to IME.  It depends on the IME or platform spec what
    * will occur (or not occur).
    */
   static nsresult NotifyIME(const IMENotification& aNotification,
                             nsIWidget* aWidget,
-                            TabParent* aTabParent = nullptr);
+                            BrowserParent* aBrowserParent = nullptr);
   static nsresult NotifyIME(IMEMessage aMessage, nsIWidget* aWidget,
-                            TabParent* aTabParent = nullptr);
+                            BrowserParent* aBrowserParent = nullptr);
   static nsresult NotifyIME(IMEMessage aMessage, nsPresContext* aPresContext,
-                            TabParent* aTabParent = nullptr);
+                            BrowserParent* aBrowserParent = nullptr);
 
   static nsINode* GetRootEditableNode(nsPresContext* aPresContext,
                                       nsIContent* aContent);
 
   /**
    * Returns active IMEContentObserver but may be nullptr if focused content
    * isn't editable or focus in a remote process.
    */
@@ -311,20 +314,20 @@ class IMEStateManager {
   // document has focus but there is no focused element, sContent may be
   // nullptr.
   static StaticRefPtr<nsIContent> sContent;
   static StaticRefPtr<nsPresContext> sPresContext;
   // sWidget is cache for the root widget of sPresContext.  Even afer
   // sPresContext has gone, we need to clean up some IME state on the widget
   // if the widget is available.
   static nsIWidget* sWidget;
-  // sFocusedIMETabParent is the tab parent, which send "focus" notification to
-  // sFocusedIMEWidget (and didn't yet sent "blur" notification).
+  // sFocusedIMEBrowserParent is the tab parent, which send "focus" notification
+  // to sFocusedIMEWidget (and didn't yet sent "blur" notification).
   static nsIWidget* sFocusedIMEWidget;
-  static StaticRefPtr<TabParent> sFocusedIMETabParent;
+  static StaticRefPtr<BrowserParent> sFocusedIMEBrowserParent;
   // sActiveInputContextWidget is the last widget whose SetInputContext() is
   // called.  This is important to reduce sync IPC cost with parent process.
   // If IMEStateManager set input context to different widget, PuppetWidget can
   // return cached input context safely.
   static nsIWidget* sActiveInputContextWidget;
   // sActiveIMEContentObserver points to the currently active
   // IMEContentObserver.  This is null if there is no focused editor.
   static StaticRefPtr<IMEContentObserver> sActiveIMEContentObserver;
@@ -333,19 +336,19 @@ class IMEStateManager {
   // When you get an item of this array and use it, please be careful.
   // The instances in this array can be destroyed automatically if you do
   // something to cause committing or canceling the composition.
   static TextCompositionArray* sTextCompositions;
 
   // Origin type of current process.
   static InputContext::Origin sOrigin;
 
-  // sActiveChildInputContext is valid only when TabParent::GetFocused() is not
-  // nullptr.  This stores last information of input context in the remote
-  // process of TabParent::GetFocused().  I.e., they are set when
+  // sActiveChildInputContext is valid only when BrowserParent::GetFocused() is
+  // not nullptr.  This stores last information of input context in the remote
+  // process of BrowserParent::GetFocused().  I.e., they are set when
   // SetInputContextForChildProcess() is called.  This is necessary for
   // restoring IME state when menu keyboard listener is uninstalled.
   static InputContext sActiveChildInputContext;
 
   // sInstalledMenuKeyboardListener is true if menu keyboard listener is
   // installed in the process.
   static bool sInstalledMenuKeyboardListener;
 
--- a/dom/events/TextComposition.cpp
+++ b/dom/events/TextComposition.cpp
@@ -17,17 +17,17 @@
 #include "mozilla/MiscEvents.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/RangeBoundary.h"
 #include "mozilla/StaticPrefs.h"
 #include "mozilla/TextComposition.h"
 #include "mozilla/TextEvents.h"
 #include "mozilla/Unused.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 
 #ifdef XP_MACOSX
 // Some defiens will be conflict with OSX SDK
 #  define TextRange _TextRange
 #  define TextRangeArray _TextRangeArray
 #  define Comment _Comment
 #endif
 
@@ -47,21 +47,21 @@ namespace mozilla {
 
 /******************************************************************************
  * TextComposition
  ******************************************************************************/
 
 bool TextComposition::sHandlingSelectionEvent = false;
 
 TextComposition::TextComposition(nsPresContext* aPresContext, nsINode* aNode,
-                                 TabParent* aTabParent,
+                                 BrowserParent* aBrowserParent,
                                  WidgetCompositionEvent* aCompositionEvent)
     : mPresContext(aPresContext),
       mNode(aNode),
-      mTabParent(aTabParent),
+      mBrowserParent(aBrowserParent),
       mNativeContext(aCompositionEvent->mNativeIMEContext),
       mCompositionStartOffset(0),
       mTargetClauseOffsetInComposition(0),
       mCompositionStartOffsetInTextNode(UINT32_MAX),
       mCompositionLengthInTextNode(UINT32_MAX),
       mIsSynthesizedForTests(aCompositionEvent->mFlags.mIsSynthesizedForTests),
       mIsComposing(false),
       mIsEditorHandlingEvent(false),
@@ -75,33 +75,33 @@ TextComposition::TextComposition(nsPresC
           "dom.compositionevent.allow_control_characters", false)),
       mWasCompositionStringEmpty(true) {
   MOZ_ASSERT(aCompositionEvent->mNativeIMEContext.IsValid());
 }
 
 void TextComposition::Destroy() {
   mPresContext = nullptr;
   mNode = nullptr;
-  mTabParent = nullptr;
+  mBrowserParent = nullptr;
   mContainerTextNode = nullptr;
   mCompositionStartOffsetInTextNode = UINT32_MAX;
   mCompositionLengthInTextNode = UINT32_MAX;
   // TODO: If the editor is still alive and this is held by it, we should tell
   //       this being destroyed for cleaning up the stuff.
 }
 
 bool TextComposition::IsValidStateForComposition(nsIWidget* aWidget) const {
   return !Destroyed() && aWidget && !aWidget->Destroyed() &&
          mPresContext->GetPresShell() &&
          !mPresContext->PresShell()->IsDestroying();
 }
 
 bool TextComposition::MaybeDispatchCompositionUpdate(
     const WidgetCompositionEvent* aCompositionEvent) {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
   if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
     return false;
   }
 
   // Note that we don't need to dispatch eCompositionUpdate event even if
   // mHasDispatchedDOMTextEvent is false and eCompositionCommit event is
   // dispatched with empty string immediately after eCompositionStart
@@ -114,17 +114,17 @@ bool TextComposition::MaybeDispatchCompo
   }
   CloneAndDispatchAs(aCompositionEvent, eCompositionUpdate);
   return IsValidStateForComposition(aCompositionEvent->mWidget);
 }
 
 BaseEventFlags TextComposition::CloneAndDispatchAs(
     const WidgetCompositionEvent* aCompositionEvent, EventMessage aMessage,
     nsEventStatus* aStatus, EventDispatchingCallback* aCallBack) {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
   MOZ_ASSERT(IsValidStateForComposition(aCompositionEvent->mWidget),
              "Should be called only when it's safe to dispatch an event");
 
   WidgetCompositionEvent compositionEvent(aCompositionEvent->IsTrusted(),
                                           aMessage, aCompositionEvent->mWidget);
   compositionEvent.mTime = aCompositionEvent->mTime;
   compositionEvent.mTimeStamp = aCompositionEvent->mTimeStamp;
@@ -165,19 +165,19 @@ void TextComposition::DispatchEvent(
 void TextComposition::OnCompositionEventDiscarded(
     WidgetCompositionEvent* aCompositionEvent) {
   // Note that this method is never called for synthesized events for emulating
   // commit or cancel composition.
 
   MOZ_ASSERT(aCompositionEvent->IsTrusted(),
              "Shouldn't be called with untrusted event");
 
-  if (mTabParent) {
+  if (mBrowserParent) {
     // The composition event should be discarded in the child process too.
-    Unused << mTabParent->SendCompositionEvent(*aCompositionEvent);
+    Unused << mBrowserParent->SendCompositionEvent(*aCompositionEvent);
   }
 
   // XXX If composition events are discarded, should we dispatch them with
   //     runnable event?  However, even if we do so, it might make native IME
   //     confused due to async modification.  Especially when native IME is
   //     TSF.
   if (!aCompositionEvent->CausesDOMCompositionEndEvent()) {
     return;
@@ -250,20 +250,20 @@ void TextComposition::DispatchCompositio
   // Then, synthesized events which were dispatched immediately after
   // the request has already committed our editor's composition string and
   // told it to web apps.  Therefore, we should ignore the delayed events.
   if (mRequestedToCommitOrCancel && !aIsSynthesized) {
     *aStatus = nsEventStatus_eConsumeNoDefault;
     return;
   }
 
-  // If the content is a container of TabParent, composition should be in the
-  // remote process.
-  if (mTabParent) {
-    Unused << mTabParent->SendCompositionEvent(*aCompositionEvent);
+  // If the content is a container of BrowserParent, composition should be in
+  // the remote process.
+  if (mBrowserParent) {
+    Unused << mBrowserParent->SendCompositionEvent(*aCompositionEvent);
     aCompositionEvent->StopPropagation();
     if (aCompositionEvent->CausesDOMTextEvent()) {
       mLastData = aCompositionEvent->mData;
       mLastRanges = aCompositionEvent->mRanges;
       // Although, the composition event hasn't been actually handled yet,
       // emulate an editor to be handling the composition event.
       EditorWillHandleCompositionChangeEvent(aCompositionEvent);
       EditorDidHandleCompositionChangeEvent();
@@ -412,22 +412,22 @@ void TextComposition::DispatchCompositio
     MOZ_ASSERT(!HasEditor(), "Why does the editor still keep to hold this?");
   }
 
   MaybeNotifyIMEOfCompositionEventHandled(aCompositionEvent);
 }
 
 // static
 void TextComposition::HandleSelectionEvent(
-    nsPresContext* aPresContext, TabParent* aTabParent,
+    nsPresContext* aPresContext, BrowserParent* aBrowserParent,
     WidgetSelectionEvent* aSelectionEvent) {
-  // If the content is a container of TabParent, composition should be in the
-  // remote process.
-  if (aTabParent) {
-    Unused << aTabParent->SendSelectionEvent(*aSelectionEvent);
+  // If the content is a container of BrowserParent, composition should be in
+  // the remote process.
+  if (aBrowserParent) {
+    Unused << aBrowserParent->SendSelectionEvent(*aSelectionEvent);
     aSelectionEvent->StopPropagation();
     return;
   }
 
   ContentEventHandler handler(aPresContext);
   AutoRestore<bool> saveHandlingSelectionEvent(sHandlingSelectionEvent);
   sHandlingSelectionEvent = true;
   // XXX During setting selection, a selection listener may change selection
@@ -480,17 +480,17 @@ uint32_t TextComposition::GetSelectionSt
   if (NS_WARN_IF(!selectedTextEvent.mSucceeded)) {
     return 0;  // XXX Is this okay?
   }
   return selectedTextEvent.mReply.mOffset;
 }
 
 void TextComposition::OnCompositionEventDispatched(
     const WidgetCompositionEvent* aCompositionEvent) {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
   if (!IsValidStateForComposition(aCompositionEvent->mWidget)) {
     return;
   }
 
   // Every composition event may cause changing composition start offset,
   // especially when there is no composition string.  Therefore, we need to
   // update mCompositionStartOffset with the latest offset.
@@ -600,33 +600,33 @@ nsresult TextComposition::RequestToCommi
   } else {
     DispatchCompositionEventRunnable(eCompositionCommit, data, true);
   }
   return NS_OK;
 }
 
 nsresult TextComposition::NotifyIME(IMEMessage aMessage) {
   NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE);
-  return IMEStateManager::NotifyIME(aMessage, mPresContext, mTabParent);
+  return IMEStateManager::NotifyIME(aMessage, mPresContext, mBrowserParent);
 }
 
 void TextComposition::EditorWillHandleCompositionChangeEvent(
     const WidgetCompositionEvent* aCompositionChangeEvent) {
   mIsComposing = aCompositionChangeEvent->IsComposing();
   mRanges = aCompositionChangeEvent->mRanges;
   mIsEditorHandlingEvent = true;
 
   MOZ_ASSERT(
       mLastData == aCompositionChangeEvent->mData,
       "The text of a compositionchange event must be same as previous data "
       "attribute value of the latest compositionupdate event");
 }
 
 void TextComposition::OnEditorDestroyed() {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
   MOZ_ASSERT(!mIsEditorHandlingEvent,
              "The editor should have stopped listening events");
   nsCOMPtr<nsIWidget> widget = GetWidget();
   if (NS_WARN_IF(!widget)) {
     // XXX If this could happen, how do we notify IME of destroying the editor?
     return;
   }
@@ -636,24 +636,24 @@ void TextComposition::OnEditorDestroyed(
 }
 
 void TextComposition::EditorDidHandleCompositionChangeEvent() {
   mString = mLastData;
   mIsEditorHandlingEvent = false;
 }
 
 void TextComposition::StartHandlingComposition(EditorBase* aEditorBase) {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
   MOZ_ASSERT(!HasEditor(), "There is a handling editor already");
   mEditorBaseWeak = do_GetWeakReference(static_cast<nsIEditor*>(aEditorBase));
 }
 
 void TextComposition::EndHandlingComposition(EditorBase* aEditorBase) {
-  MOZ_RELEASE_ASSERT(!mTabParent);
+  MOZ_RELEASE_ASSERT(!mBrowserParent);
 
 #ifdef DEBUG
   RefPtr<EditorBase> editorBase = GetEditorBase();
   MOZ_ASSERT(!editorBase || editorBase == aEditorBase,
              "Another editor handled the composition?");
 #endif  // #ifdef DEBUG
   mEditorBaseWeak = nullptr;
 }
@@ -820,33 +820,33 @@ TextComposition::CompositionEventDispatc
       WidgetQueryContentEvent selectedText(true, eQuerySelectedText, widget);
       ContentEventHandler handler(presContext);
       handler.OnQuerySelectedText(&selectedText);
       NS_ASSERTION(selectedText.mSucceeded, "Failed to get selected text");
       compStart.mData = selectedText.mReply.mString;
       compStart.mFlags.mIsSynthesizedForTests =
           mTextComposition->IsSynthesizedForTests();
       IMEStateManager::DispatchCompositionEvent(
-          mEventTarget, presContext, mTextComposition->mTabParent, &compStart,
-          &status, nullptr, mIsSynthesizedEvent);
+          mEventTarget, presContext, mTextComposition->mBrowserParent,
+          &compStart, &status, nullptr, mIsSynthesizedEvent);
       break;
     }
     case eCompositionChange:
     case eCompositionCommitAsIs:
     case eCompositionCommit: {
       WidgetCompositionEvent compEvent(true, mEventMessage, widget);
       compEvent.mNativeIMEContext = mTextComposition->mNativeContext;
       if (mEventMessage != eCompositionCommitAsIs) {
         compEvent.mData = mData;
       }
       compEvent.mFlags.mIsSynthesizedForTests =
           mTextComposition->IsSynthesizedForTests();
       IMEStateManager::DispatchCompositionEvent(
-          mEventTarget, presContext, mTextComposition->mTabParent, &compEvent,
-          &status, nullptr, mIsSynthesizedEvent);
+          mEventTarget, presContext, mTextComposition->mBrowserParent,
+          &compEvent, &status, nullptr, mIsSynthesizedEvent);
       break;
     }
     default:
       MOZ_CRASH("Unsupported event");
   }
   return NS_OK;
 }
 
--- a/dom/events/TextComposition.h
+++ b/dom/events/TextComposition.h
@@ -13,17 +13,17 @@
 #include "nsIWidget.h"
 #include "nsTArray.h"
 #include "nsThreadUtils.h"
 #include "nsPresContext.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/EventForwards.h"
 #include "mozilla/RangeBoundary.h"
 #include "mozilla/TextRange.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/dom/Text.h"
 
 namespace mozilla {
 
 class EditorBase;
 class EventDispatchingCallback;
 class IMEStateManager;
 
@@ -34,23 +34,23 @@ class IMEStateManager;
  */
 
 class TextComposition final {
   friend class IMEStateManager;
 
   NS_INLINE_DECL_REFCOUNTING(TextComposition)
 
  public:
-  typedef dom::TabParent TabParent;
+  typedef dom::BrowserParent BrowserParent;
   typedef dom::Text Text;
 
   static bool IsHandlingSelectionEvent() { return sHandlingSelectionEvent; }
 
   TextComposition(nsPresContext* aPresContext, nsINode* aNode,
-                  TabParent* aTabParent,
+                  BrowserParent* aBrowserParent,
                   WidgetCompositionEvent* aCompositionEvent);
 
   bool Destroyed() const { return !mPresContext; }
   nsPresContext* GetPresContext() const { return mPresContext; }
   nsINode* GetEventTargetNode() const { return mNode; }
   // The text node which includes composition string.
   Text* GetContainerTextNode() const { return mContainerTextNode; }
   // The latest CompositionEvent.data value except compositionstart event.
@@ -73,17 +73,17 @@ class TextComposition final {
   // XXX We should return |const TextRangeArray*| here, but it causes compile
   //     error due to inaccessible Release() method.
   TextRangeArray* GetRanges() const { return mRanges; }
   // Returns the widget which is proper to call NotifyIME().
   nsIWidget* GetWidget() const {
     return mPresContext ? mPresContext->GetRootWidget() : nullptr;
   }
   // Returns the tab parent which has this composition in its remote process.
-  TabParent* GetTabParent() const { return mTabParent; }
+  BrowserParent* GetBrowserParent() const { return mBrowserParent; }
   // Returns true if the composition is started with synthesized event which
   // came from nsDOMWindowUtils.
   bool IsSynthesizedForTests() const { return mIsSynthesizedForTests; }
 
   const widget::NativeIMEContext& GetNativeIMEContext() const {
     return mNativeContext;
   }
 
@@ -283,17 +283,17 @@ class TextComposition final {
   static bool sHandlingSelectionEvent;
 
   // This class holds nsPresContext weak.  This instance shouldn't block
   // destroying it.  When the presContext is being destroyed, it's notified to
   // IMEStateManager::OnDestroyPresContext(), and then, it destroy
   // this instance.
   nsPresContext* mPresContext;
   nsCOMPtr<nsINode> mNode;
-  RefPtr<TabParent> mTabParent;
+  RefPtr<BrowserParent> mBrowserParent;
 
   // The text node which includes the composition string.
   RefPtr<Text> mContainerTextNode;
 
   // This is the clause and caret range information which is managed by
   // the focused editor.  This may be null if there is no clauses or caret.
   RefPtr<TextRangeArray> mRanges;
   // Same as mRange, but mRange will have old data during compositionupdate.
@@ -465,22 +465,22 @@ class TextComposition final {
 
   /**
    * HandleSelectionEvent() sends the selection event to ContentEventHandler
    * or dispatches it to the focused child process.
    */
   MOZ_CAN_RUN_SCRIPT
   void HandleSelectionEvent(WidgetSelectionEvent* aSelectionEvent) {
     RefPtr<nsPresContext> presContext(mPresContext);
-    RefPtr<TabParent> tabParent(mTabParent);
-    HandleSelectionEvent(presContext, tabParent, aSelectionEvent);
+    RefPtr<BrowserParent> browserParent(mBrowserParent);
+    HandleSelectionEvent(presContext, browserParent, aSelectionEvent);
   }
   MOZ_CAN_RUN_SCRIPT
   static void HandleSelectionEvent(nsPresContext* aPresContext,
-                                   TabParent* aTabParent,
+                                   BrowserParent* aBrowserParent,
                                    WidgetSelectionEvent* aSelectionEvent);
 
   /**
    * MaybeDispatchCompositionUpdate() may dispatch a compositionupdate event
    * if aCompositionEvent changes composition string.
    * @return Returns false if dispatching the compositionupdate event caused
    *         destroying this composition.
    */
--- a/dom/events/test/test_bug1412775.xul
+++ b/dom/events/test/test_bug1412775.xul
@@ -25,17 +25,17 @@ https://bugzilla.mozilla.org/show_bug.cg
       var e = new d.defaultView.Event("foo");
       var didCallChromeSide = false;
       var didCallContentSide = false;
       b.addEventListener("foo", function(e) {
         didCallChromeSide = true;
         var path = e.composedPath();
         var mm = d.defaultView.docShell.messageManager;
         is(path.length, 5, "Should have 5 items in composedPath in chrome.");
-        is(path[0], mm, "TabChildGlobal is the chrome handler.");
+        is(path[0], mm, "BrowserChildGlobal is the chrome handler.");
         is(path[1], b, "browser element should be in the path.");
         is(path[2], b.parentNode, "window element should be in the path.");
         is(path[3], win.document, "Document object should be in the path.");
         is(path[4], win, "Window object should be in the path.");
       }, true, true);
       d.addEventListener("foo", function(e) {
         didCallContentSide = true;;
         var path = e.composedPath();
--- a/dom/html/nsGenericHTMLFrameElement.cpp
+++ b/dom/html/nsGenericHTMLFrameElement.cpp
@@ -128,21 +128,21 @@ void nsGenericHTMLFrameElement::EnsureFr
   }
 
   // Strangely enough, this method doesn't actually ensure that the
   // frameloader exists.  It's more of a best-effort kind of thing.
   mFrameLoader = nsFrameLoader::Create(this, mOpenerWindow, mNetworkCreated);
 }
 
 nsresult nsGenericHTMLFrameElement::CreateRemoteFrameLoader(
-    nsITabParent* aTabParent) {
+    nsIRemoteTab* aBrowserParent) {
   MOZ_ASSERT(!mFrameLoader);
   EnsureFrameLoader();
   NS_ENSURE_STATE(mFrameLoader);
-  mFrameLoader->SetRemoteBrowser(aTabParent);
+  mFrameLoader->SetRemoteBrowser(aBrowserParent);
 
   if (nsSubDocumentFrame* subdocFrame = do_QueryFrame(GetPrimaryFrame())) {
     // The reflow for this element already happened while we were waiting
     // for the iframe creation. Therefore the subdoc frame didn't have a
     // frameloader when UpdatePositionAndSize was supposed to be called in
     // ReflowFinished, and we need to do it properly now.
     mFrameLoader->UpdatePositionAndSize(subdocFrame);
   }
--- a/dom/indexedDB/ActorsChild.cpp
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -21,17 +21,17 @@
 #include "IndexedDatabaseInlines.h"
 #include "mozilla/BasicEvents.h"
 #include "mozilla/CycleCollectedJSRuntime.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/TypeTraits.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/PermissionMessageUtils.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileChild.h"
 #include "mozilla/dom/ipc/PendingIPCBlobChild.h"
 #include "mozilla/dom/IPCBlobUtils.h"
 #include "mozilla/dom/WorkerPrivate.h"
 #include "mozilla/dom/WorkerRunnable.h"
 #include "mozilla/Encoding.h"
 #include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/TaskQueue.h"
@@ -939,23 +939,23 @@ class WorkerPermissionChallenge final : 
 
       MOZ_ASSERT(permission == PermissionRequestBase::kPermissionAllowed ||
                  permission == PermissionRequestBase::kPermissionDenied ||
                  permission == PermissionRequestBase::kPermissionPrompt);
 
       return permission != PermissionRequestBase::kPermissionPrompt;
     }
 
-    TabChild* tabChild = TabChild::GetFrom(window);
-    MOZ_ASSERT(tabChild);
+    BrowserChild* browserChild = BrowserChild::GetFrom(window);
+    MOZ_ASSERT(browserChild);
 
     IPC::Principal ipcPrincipal(principal);
 
     RefPtr<WorkerPermissionChallenge> self(this);
-    tabChild->SendIndexedDBPermissionRequest(ipcPrincipal)
+    browserChild->SendIndexedDBPermissionRequest(ipcPrincipal)
         ->Then(
             GetCurrentThreadSerialEventTarget(), __func__,
             [self](const uint32_t& aPermission) { self->OperationCompleted(); },
             [](const mozilla::ipc::ResponseRejectReason) {});
     return false;
   }
 
  private:
@@ -1709,22 +1709,22 @@ mozilla::ipc::IPCResult BackgroundFactor
                permission == PermissionRequestBase::kPermissionPrompt);
 
     if (permission != PermissionRequestBase::kPermissionPrompt) {
       SendPermissionRetry();
     }
     return IPC_OK();
   }
 
-  RefPtr<TabChild> tabChild = mFactory->GetTabChild();
-  MOZ_ASSERT(tabChild);
+  RefPtr<BrowserChild> browserChild = mFactory->GetBrowserChild();
+  MOZ_ASSERT(browserChild);
 
   IPC::Principal ipcPrincipal(principal);
 
-  tabChild->SendIndexedDBPermissionRequest(ipcPrincipal)
+  browserChild->SendIndexedDBPermissionRequest(ipcPrincipal)
       ->Then(
           GetCurrentThreadSerialEventTarget(), __func__,
           [this](const uint32_t& aPermission) {
             this->AssertIsOnOwningThread();
             MaybeCollectGarbageOnIPCMessage();
             this->SendPermissionRetry();
           },
           [](const mozilla::ipc::ResponseRejectReason) {});
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -35,17 +35,17 @@
 #include "mozilla/storage.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/Unused.h"
 #include "mozilla/UniquePtrExtensions.h"
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/File.h"
 #include "mozilla/dom/FileBlobImpl.h"
 #include "mozilla/dom/StructuredCloneTags.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 #include "mozilla/dom/filehandle/ActorsParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBCursorParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseRequestParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBFactoryParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBFactoryRequestParent.h"
 #include "mozilla/dom/indexedDB/PBackgroundIDBRequestParent.h"
@@ -11064,18 +11064,18 @@ void ConnectionPool::ShutdownThread(Thre
   aThreadInfo.mThread.swap(thread);
 
   IDB_DEBUG_LOG(("ConnectionPool shutting down thread %" PRIu32,
                  runnable->SerialNumber()));
 
   // This should clean up the thread with the profiler.
   MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL));
 
-  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(
-      NewRunnableMethod("nsIThread::Shutdown", thread, &nsIThread::Shutdown)));
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(NewRunnableMethod(
+      "nsIThread::AsyncShutdown", thread, &nsIThread::AsyncShutdown)));
 
   mTotalThreadCount--;
 }
 
 void ConnectionPool::CloseIdleDatabases() {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mShutdownRequested);
 
--- a/dom/indexedDB/IDBFactory.cpp
+++ b/dom/indexedDB/IDBFactory.cpp
@@ -10,17 +10,17 @@
 #include "IDBRequest.h"
 #include "IndexedDatabaseManager.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/SystemGroup.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/IDBFactoryBinding.h"
 #include "mozilla/dom/quota/QuotaManager.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 #include "mozilla/ipc/BackgroundChild.h"
 #include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/ipc/PBackground.h"
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/StaticPrefs.h"
 #include "mozilla/Telemetry.h"
 #include "mozIThirdPartyUtil.h"
 #include "nsAboutProtocolUtils.h"
@@ -138,17 +138,17 @@ nsresult IDBFactory::CreateForWindow(nsP
   nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(webNav);
 
   RefPtr<IDBFactory> factory = new IDBFactory();
   factory->mPrincipalInfo = std::move(principalInfo);
 
   factory->mGlobal = do_QueryInterface(aWindow);
   MOZ_ASSERT(factory->mGlobal);
 
-  factory->mTabChild = TabChild::GetFrom(aWindow);
+  factory->mBrowserChild = BrowserChild::GetFrom(aWindow);
   factory->mEventTarget =
       nsGlobalWindowInner::Cast(aWindow)->EventTargetFor(TaskCategory::Other);
   factory->mInnerWindowID = aWindow->WindowID();
   factory->mPrivateBrowsingMode =
       loadContext && loadContext->UsePrivateBrowsing();
 
   factory.forget(aFactory);
   return NS_OK;
@@ -829,24 +829,24 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(IDBFactory)
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IDBFactory)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTabChild)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChild)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventTarget)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(IDBFactory)
   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTabChild)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChild)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventTarget)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(IDBFactory)
   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
 JSObject* IDBFactory::WrapObject(JSContext* aCx,
--- a/dom/indexedDB/IDBFactory.h
+++ b/dom/indexedDB/IDBFactory.h
@@ -35,17 +35,17 @@ class PrincipalInfo;
 }  // namespace ipc
 
 namespace dom {
 
 struct IDBOpenDBOptions;
 class IDBOpenDBRequest;
 template <typename>
 class Optional;
-class TabChild;
+class BrowserChild;
 enum class CallerType : uint32_t;
 
 namespace indexedDB {
 class BackgroundFactoryChild;
 class FactoryRequestParams;
 class LoggingInfo;
 }  // namespace indexedDB
 
@@ -58,17 +58,17 @@ class IDBFactory final : public nsISuppo
   struct PendingRequestInfo;
 
   nsAutoPtr<PrincipalInfo> mPrincipalInfo;
 
   nsCOMPtr<nsIGlobalObject> mGlobal;
 
   // This will only be set if the factory belongs to a window in a child
   // process.
-  RefPtr<TabChild> mTabChild;
+  RefPtr<BrowserChild> mBrowserChild;
 
   indexedDB::BackgroundFactoryChild* mBackgroundActor;
 
   // It is either set to a DocGroup-specific EventTarget if created by
   // CreateForWindow() or set to GetCurrentThreadEventTarget() otherwise.
   nsCOMPtr<nsIEventTarget> mEventTarget;
 
   uint64_t mInnerWindowID;
@@ -120,17 +120,17 @@ class IDBFactory final : public nsISuppo
   // Note: A non-closed database or a pending IDBOpenRequest could block
   // IDB operations in other window.
   void UpdateActiveDatabaseCount(int32_t aDelta);
 
   void IncrementParentLoggingRequestSerialNumber();
 
   nsIGlobalObject* GetParentObject() const { return mGlobal; }
 
-  TabChild* GetTabChild() const { return mTabChild; }
+  BrowserChild* GetBrowserChild() const { return mBrowserChild; }
 
   PrincipalInfo* GetPrincipalInfo() const {
     AssertIsOnOwningThread();
 
     return mPrincipalInfo;
   }
 
   uint64_t InnerWindowID() const {
--- a/dom/interfaces/base/moz.build
+++ b/dom/interfaces/base/moz.build
@@ -5,28 +5,28 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 with Files("**"):
     BUG_COMPONENT = ("Core", "DOM: Core & HTML")
 
 XPIDL_SOURCES += [
     'domstubs.idl',
     'nsIBrowser.idl',
+    'nsIBrowserChild.idl',
     'nsIBrowserDOMWindow.idl',
     'nsIContentPermissionPrompt.idl',
     'nsIContentPrefService2.idl',
     'nsIContentProcess.idl',
     'nsIDOMChromeWindow.idl',
     'nsIDOMGlobalPropertyInitializer.idl',
     'nsIDOMWindow.idl',
     'nsIDOMWindowUtils.idl',
     'nsIFocusManager.idl',
     'nsIQueryContentEventResult.idl',
+    'nsIRemoteTab.idl',
     'nsIServiceWorkerManager.idl',
     'nsIStructuredCloneContainer.idl',
-    'nsITabChild.idl',
-    'nsITabParent.idl',
     'nsITextInputProcessor.idl',
     'nsITextInputProcessorCallback.idl',
 ]
 
 XPIDL_MODULE = 'dom_base'
 
--- a/dom/interfaces/base/nsIBrowser.idl
+++ b/dom/interfaces/base/nsIBrowser.idl
@@ -10,17 +10,17 @@ interface nsIWebProgress;
 webidl FrameLoader;
 
 [scriptable, uuid(14e5a0cb-e223-4202-95e8-fe53275193ea)]
 interface nsIBrowser : nsISupports
 {
   /**
    * Gets an optional frame loader that is "related" to this browser.
    * If this exists, then we should attempt to use the same content parent as
-   * this frame loader for any new tab parents.  For example, view source
+   * this frame loader for any new remote tabs.  For example, view source
    * browsers set this to the frame loader for the original content to ensure
    * they are loaded in the same process as the content.
    */
   readonly attribute FrameLoader sameProcessAsFrameLoader;
 
   /*
    * Called by the child to inform the parent that links are dropped into
    * content area.
rename from dom/interfaces/base/nsITabChild.idl
rename to dom/interfaces/base/nsIBrowserChild.idl
--- a/dom/interfaces/base/nsITabChild.idl
+++ b/dom/interfaces/base/nsIBrowserChild.idl
@@ -9,17 +9,17 @@
 interface nsIWebBrowserChrome3;
 
 webidl ContentFrameMessageManager;
 
 native CommandsArray(nsTArray<nsCString>);
 [ref] native CommandsArrayRef(nsTArray<nsCString>);
 
 [scriptable, uuid(1fb79c27-e760-4088-b19c-1ce3673ec24e)]
-interface nsITabChild : nsISupports
+interface nsIBrowserChild : nsISupports
 {
   readonly attribute ContentFrameMessageManager messageManager;
 
   attribute nsIWebBrowserChrome3 webBrowserChrome;
 
   [notxpcom] void sendRequestFocus(in boolean canFocus);
 
   [noscript, notxpcom] void enableDisableCommands(in AString action,
--- a/dom/interfaces/base/nsIBrowserDOMWindow.idl
+++ b/dom/interfaces/base/nsIBrowserDOMWindow.idl
@@ -115,24 +115,24 @@ interface nsIBrowserDOMWindow : nsISuppo
                       in nsIPrincipal aTriggeringPrincipal,
                       [optional] in nsIContentSecurityPolicy aCsp);
 
   /**
    * As above, but return the nsFrameLoaderOwner for the new window. Value is
    * returned as Element, QI'd back to nsFrameLoaderOwner as needed.
    *
    * Additional Parameters:
-   * @param aNextTabParentId The TabParent to associate the window with.
+   * @param aNextRemoteTabId The RemoteTab to associate the window with.
    * @param aName The name to give the window opened in the new tab.
    * @return The frame element for the newly opened window.
    */
   Element
   createContentWindowInFrame(in nsIURI aURI, in nsIOpenURIInFrameParams params,
                              in short aWhere, in long aFlags,
-                             in unsigned long long aNextTabParentId,
+                             in unsigned long long aNextRemoteTabId,
                              in AString aName);
 
   /**
    * Load a URI.
 
    * @param aURI the URI to open. null is not allowed. To create the window
    *        without loading the URI, use createContentWindow instead.
    * @param aWhere see possible values described above.
@@ -149,26 +149,26 @@ interface nsIBrowserDOMWindow : nsISuppo
           in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal,
           [optional] in nsIContentSecurityPolicy aCsp);
 
   /**
    * As above, but return the nsFrameLoaderOwner for the new window. Value is
    * returned as Element, QI'd back to nsFrameLoaderOwner as needed.
    *
    * Additional Parameters:
-   * @param aNextTabParentId The TabParent to associate the window with.
+   * @param aNextRemoteTabId The RemoteTab to associate the window with.
    * @param aName The name to give the window opened in the new tab.
    * @return The frame element for the newly opened window.
    // XXXbz is this the right API?
    // See bug 537428
    */
   Element
   openURIInFrame(in nsIURI aURI, in nsIOpenURIInFrameParams params,
                  in short aWhere, in long aFlags,
-                 in unsigned long long aNextTabParentId,
+                 in unsigned long long aNextRemoteTabId,
                  in AString aName);
 
   /**
    * @param  aWindow the window to test.
    * @return whether the window is the main content window for any
    *         currently open tab in this toplevel browser window.
    */
   boolean isTabContentWindow(in nsIDOMWindow aWindow);
rename from dom/interfaces/base/nsITabParent.idl
rename to dom/interfaces/base/nsIRemoteTab.idl
--- a/dom/interfaces/base/nsITabParent.idl
+++ b/dom/interfaces/base/nsIRemoteTab.idl
@@ -4,17 +4,17 @@
 
 
 #include "domstubs.idl"
 
 interface nsIPrincipal;
 webidl Element;
 
 [builtinclass, scriptable, uuid(8e49f7b0-1f98-4939-bf91-e9c39cd56434)]
-interface nsITabParent : nsISupports
+interface nsIRemoteTab : nsISupports
 {
   /**
    * Manages the docshell active state of the remote browser. Setting the
    * docShell to be active will also cause it to render layers and upload
    * them to the compositor. Setting the docShell as not active will clear
    * those layers.
    */
   attribute boolean docShellIsActive;
@@ -64,29 +64,29 @@ interface nsITabParent : nsISupports
   readonly attribute boolean hasContentOpener;
   /**
    * True if we've previously received layers for this tab when switching to
    * it.
    */
   readonly attribute boolean hasPresented;
 
   /**
-   * Ensures that the content process which has this tab parent has all of the
+   * Ensures that the content process which has this remote tab has all of the
    * permissions required to load a document with the given principal.
    */
   void transmitPermissionsForPrincipal(in nsIPrincipal aPrincipal);
 
   /**
-   * True if any of the frames loaded in the TabChild have registered
+   * True if any of the frames loaded in the tab have registered
    * an onbeforeunload event handler.
    */
   readonly attribute boolean hasBeforeUnload;
 
   /**
-   * The frame element which currently embeds this nsITabParent object.
+   * The frame element which currently embeds this nsIRemoteTab object.
    */
   readonly attribute Element ownerElement;
 
   /**
    * Notify APZ to start autoscrolling.
    * (aAnchorX, aAnchorY) are the coordinates of the autoscroll anchor,
    * in CSS coordinates relative to the screen. aScrollId and 
    * aPresShellId identify the scroll frame that content chose to scroll.
--- a/dom/interfaces/html/nsIMozBrowserFrame.idl
+++ b/dom/interfaces/html/nsIMozBrowserFrame.idl
@@ -2,17 +2,17 @@
 /* vim:set tw=80 expandtab softtabstop=2 ts=2 sw=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 "nsIDOMMozBrowserFrame.idl"
 
-interface nsITabParent;
+interface nsIRemoteTab;
 
 [scriptable, builtinclass, uuid(0c0a862c-1a47-43c0-ae9e-d51835e3e1a6)]
 interface nsIMozBrowserFrame : nsIDOMMozBrowserFrame
 {
   /**
    * Gets whether this frame really is a browser frame.
    *
    * In order to really be a browser frame, this frame's
@@ -48,21 +48,21 @@ interface nsIMozBrowserFrame : nsIDOMMoz
    *
    * It's also an error to call either method if we already have a frame loader.
    */
   void disallowCreateFrameLoader();
   void allowCreateFrameLoader();
 
   /**
    * Create a remote (i.e., out-of-process) frame loader attached to the given
-   * tab parent.
+   * remote tab.
    *
    * It is an error to call this method if we already have a frame loader.
    */
-  void createRemoteFrameLoader(in nsITabParent aTabParent);
+  void createRemoteFrameLoader(in nsIRemoteTab aRemoteTab);
 
   /**
    * Initialize the API, and add frame message listener that supports API
    * invocations.
    */
   [noscript] void initializeBrowserAPI();
 
   /**
--- a/dom/ipc/BrowserBridgeChild.cpp
+++ b/dom/ipc/BrowserBridgeChild.cpp
@@ -26,25 +26,25 @@ BrowserBridgeChild::BrowserBridgeChild(n
 
 BrowserBridgeChild::~BrowserBridgeChild() {}
 
 already_AddRefed<BrowserBridgeChild> BrowserBridgeChild::Create(
     nsFrameLoader* aFrameLoader, const TabContext& aContext,
     const nsString& aRemoteType, BrowsingContext* aBrowsingContext) {
   MOZ_ASSERT(XRE_IsContentProcess());
 
-  // Determine our embedder's TabChild actor.
+  // Determine our embedder's BrowserChild actor.
   RefPtr<Element> owner = aFrameLoader->GetOwnerContent();
   MOZ_DIAGNOSTIC_ASSERT(owner);
 
   nsCOMPtr<nsIDocShell> docShell = do_GetInterface(owner->GetOwnerGlobal());
   MOZ_DIAGNOSTIC_ASSERT(docShell);
 
-  RefPtr<TabChild> tabChild = TabChild::GetFrom(docShell);
-  MOZ_DIAGNOSTIC_ASSERT(tabChild);
+  RefPtr<BrowserChild> browserChild = BrowserChild::GetFrom(docShell);
+  MOZ_DIAGNOSTIC_ASSERT(browserChild);
 
   uint32_t chromeFlags = 0;
 
   nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
   if (docShell) {
     docShell->GetTreeOwner(getter_AddRefs(treeOwner));
   }
   if (treeOwner) {
@@ -61,18 +61,18 @@ already_AddRefed<BrowserBridgeChild> Bro
     chromeFlags |= nsIWebBrowserChrome::CHROME_PRIVATE_WINDOW;
   }
   if (docShell->GetAffectPrivateSessionLifetime()) {
     chromeFlags |= nsIWebBrowserChrome::CHROME_PRIVATE_LIFETIME;
   }
 
   RefPtr<BrowserBridgeChild> browserBridge =
       new BrowserBridgeChild(aFrameLoader, aBrowsingContext);
-  // Reference is freed in TabChild::DeallocPBrowserBridgeChild.
-  tabChild->SendPBrowserBridgeConstructor(
+  // Reference is freed in BrowserChild::DeallocPBrowserBridgeChild.
+  browserChild->SendPBrowserBridgeConstructor(
       do_AddRef(browserBridge).take(),
       PromiseFlatString(aContext.PresentationURL()), aRemoteType,
       aBrowsingContext, chromeFlags);
   browserBridge->mIPCOpen = true;
 
   return browserBridge.forget();
 }
 
@@ -139,17 +139,17 @@ IPCResult BrowserBridgeChild::RecvSetLay
     const mozilla::layers::LayersId& aLayersId) {
   MOZ_ASSERT(!mLayersId.IsValid() && aLayersId.IsValid());
   mLayersId = aLayersId;
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult BrowserBridgeChild::RecvRequestFocus(
     const bool& aCanRaise) {
-  // Adapted from TabParent
+  // Adapted from BrowserParent
   nsCOMPtr<nsIFocusManager> fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return IPC_OK();
   }
 
   RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
 
   if (!owner || !owner->OwnerDoc()) {
@@ -162,17 +162,17 @@ mozilla::ipc::IPCResult BrowserBridgeChi
   }
 
   fm->SetFocus(owner, flags);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult BrowserBridgeChild::RecvMoveFocus(
     const bool& aForward, const bool& aForDocumentNavigation) {
-  // Adapted from TabParent
+  // Adapted from BrowserParent
   nsCOMPtr<nsIFocusManager> fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return IPC_OK();
   }
 
   RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
 
   if (!owner || !owner->OwnerDoc()) {
--- a/dom/ipc/BrowserBridgeChild.h
+++ b/dom/ipc/BrowserBridgeChild.h
@@ -3,32 +3,32 @@
 /* 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/. */
 
 #ifndef mozilla_dom_BrowserBridgeChild_h
 #define mozilla_dom_BrowserBridgeChild_h
 
 #include "mozilla/dom/PBrowserBridgeChild.h"
-#include "mozilla/dom/TabChild.h"
+#include "mozilla/dom/BrowserChild.h"
 
 namespace mozilla {
 namespace dom {
 class BrowsingContext;
 
 /**
  * Child side for a remote frame.
  */
 class BrowserBridgeChild : public PBrowserBridgeChild {
  public:
   NS_INLINE_DECL_REFCOUNTING(BrowserBridgeChild);
 
-  TabChild* Manager() {
+  BrowserChild* Manager() {
     MOZ_ASSERT(mIPCOpen);
-    return static_cast<TabChild*>(PBrowserBridgeChild::Manager());
+    return static_cast<BrowserChild*>(PBrowserBridgeChild::Manager());
   }
 
   mozilla::layers::LayersId GetLayersId() { return mLayersId; }
 
   BrowsingContext* GetBrowsingContext() { return mBrowsingContext; }
 
   // XXX(nika): We should have a load context here. (bug 1532664)
   nsILoadContext* GetLoadContext() { return nullptr; }
--- a/dom/ipc/BrowserBridgeParent.cpp
+++ b/dom/ipc/BrowserBridgeParent.cpp
@@ -54,112 +54,112 @@ nsresult BrowserBridgeParent::Init(const
   aBrowsingContext->SetOwnerProcessId(constructorSender->ChildID());
 
   ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
   TabId tabId(nsContentUtils::GenerateTabId());
   cpm->RegisterRemoteFrame(tabId, ContentParentId(0), TabId(0),
                            tabContext.AsIPCTabContext(),
                            constructorSender->ChildID());
 
-  // Construct the TabParent object for our subframe.
-  RefPtr<TabParent> tabParent(new TabParent(constructorSender, tabId,
-                                            tabContext, aBrowsingContext,
-                                            aChromeFlags, this));
+  // Construct the BrowserParent object for our subframe.
+  RefPtr<BrowserParent> browserParent(
+      new BrowserParent(constructorSender, tabId, tabContext, aBrowsingContext,
+                        aChromeFlags, this));
 
   // Open a remote endpoint for our PBrowser actor. DeallocPBrowserParent
   // releases the ref taken.
   ManagedEndpoint<PBrowserChild> childEp =
-      constructorSender->OpenPBrowserEndpoint(do_AddRef(tabParent).take());
+      constructorSender->OpenPBrowserEndpoint(do_AddRef(browserParent).take());
   if (NS_WARN_IF(!childEp.IsValid())) {
     MOZ_ASSERT(false, "Browser Open Endpoint Failed");
     return NS_ERROR_FAILURE;
   }
 
   // Tell the content process to set up its PBrowserChild.
   bool ok = constructorSender->SendConstructBrowser(
       std::move(childEp), tabId, TabId(0), tabContext.AsIPCTabContext(),
       aBrowsingContext, aChromeFlags, constructorSender->ChildID(),
       constructorSender->IsForBrowser());
   if (NS_WARN_IF(!ok)) {
     MOZ_ASSERT(false, "Browser Constructor Failed");
     return NS_ERROR_FAILURE;
   }
 
-  // Set our TabParent object to the newly created browser.
-  mTabParent = tabParent.forget();
-  mTabParent->SetOwnerElement(Manager()->GetOwnerElement());
-  mTabParent->InitRendering();
+  // Set our BrowserParent object to the newly created browser.
+  mBrowserParent = browserParent.forget();
+  mBrowserParent->SetOwnerElement(Manager()->GetOwnerElement());
+  mBrowserParent->InitRendering();
 
-  RenderFrame* rf = mTabParent->GetRenderFrame();
+  RenderFrame* rf = mBrowserParent->GetRenderFrame();
   if (NS_WARN_IF(!rf)) {
     MOZ_ASSERT(false, "No RenderFrame");
     return NS_ERROR_FAILURE;
   }
 
   // Send the newly created layers ID back into content.
   Unused << SendSetLayersId(rf->GetLayersId());
   return NS_OK;
 }
 
 void BrowserBridgeParent::Destroy() {
-  if (mTabParent) {
-    mTabParent->Destroy();
-    mTabParent = nullptr;
+  if (mBrowserParent) {
+    mBrowserParent->Destroy();
+    mBrowserParent = nullptr;
   }
 }
 
 IPCResult BrowserBridgeParent::RecvShow(const ScreenIntSize& aSize,
                                         const bool& aParentIsActive,
                                         const nsSizeMode& aSizeMode) {
-  RenderFrame* rf = mTabParent->GetRenderFrame();
+  RenderFrame* rf = mBrowserParent->GetRenderFrame();
   if (!rf->AttachLayerManager()) {
     MOZ_CRASH();
   }
 
-  Unused << mTabParent->SendShow(aSize, mTabParent->GetShowInfo(),
-                                 aParentIsActive, aSizeMode);
+  Unused << mBrowserParent->SendShow(aSize, mBrowserParent->GetShowInfo(),
+                                     aParentIsActive, aSizeMode);
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvLoadURL(const nsCString& aUrl) {
-  Unused << mTabParent->SendLoadURL(aUrl, mTabParent->GetShowInfo());
+  Unused << mBrowserParent->SendLoadURL(aUrl, mBrowserParent->GetShowInfo());
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvResumeLoad(uint64_t aPendingSwitchID) {
-  mTabParent->ResumeLoad(aPendingSwitchID);
+  mBrowserParent->ResumeLoad(aPendingSwitchID);
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvUpdateDimensions(
     const DimensionInfo& aDimensions) {
-  Unused << mTabParent->SendUpdateDimensions(aDimensions);
+  Unused << mBrowserParent->SendUpdateDimensions(aDimensions);
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvRenderLayers(
     const bool& aEnabled, const bool& aForceRepaint,
     const layers::LayersObserverEpoch& aEpoch) {
-  Unused << mTabParent->SendRenderLayers(aEnabled, aForceRepaint, aEpoch);
+  Unused << mBrowserParent->SendRenderLayers(aEnabled, aForceRepaint, aEpoch);
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvNavigateByKey(
     const bool& aForward, const bool& aForDocumentNavigation) {
-  Unused << mTabParent->SendNavigateByKey(aForward, aForDocumentNavigation);
+  Unused << mBrowserParent->SendNavigateByKey(aForward, aForDocumentNavigation);
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvActivate() {
-  mTabParent->Activate();
+  mBrowserParent->Activate();
   return IPC_OK();
 }
 
 IPCResult BrowserBridgeParent::RecvDeactivate() {
-  mTabParent->Deactivate();
+  mBrowserParent->Deactivate();
   return IPC_OK();
 }
 
 void BrowserBridgeParent::ActorDestroy(ActorDestroyReason aWhy) {
   mIPCOpen = false;
   Destroy();
 }
 
--- a/dom/ipc/BrowserBridgeParent.h
+++ b/dom/ipc/BrowserBridgeParent.h
@@ -3,42 +3,42 @@
 /* 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/. */
 
 #ifndef mozilla_dom_BrowserBridgeParent_h
 #define mozilla_dom_BrowserBridgeParent_h
 
 #include "mozilla/dom/PBrowserBridgeParent.h"
-#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/BrowserParent.h"
 
 namespace mozilla {
 namespace dom {
 
 class BrowserBridgeParent : public PBrowserBridgeParent {
  public:
   NS_INLINE_DECL_REFCOUNTING(BrowserBridgeParent);
 
   BrowserBridgeParent();
 
   // Initialize this actor after performing startup.
   nsresult Init(const nsString& aPresentationURL, const nsString& aRemoteType,
                 CanonicalBrowsingContext* aBrowsingContext,
                 const uint32_t& aChromeFlags);
 
-  TabParent* GetTabParent() { return mTabParent; }
+  BrowserParent* GetBrowserParent() { return mBrowserParent; }
 
   CanonicalBrowsingContext* GetBrowsingContext() {
-    return mTabParent->GetBrowsingContext();
+    return mBrowserParent->GetBrowsingContext();
   }
 
   // Get our manager actor.
-  TabParent* Manager() {
+  BrowserParent* Manager() {
     MOZ_ASSERT(mIPCOpen);
-    return static_cast<TabParent*>(PBrowserBridgeParent::Manager());
+    return static_cast<BrowserParent*>(PBrowserBridgeParent::Manager());
   }
 
   // Tear down this BrowserBridgeParent.
   void Destroy();
 
  protected:
   friend class PBrowserBridgeParent;
 
@@ -60,16 +60,16 @@ class BrowserBridgeParent : public PBrow
 
   mozilla::ipc::IPCResult RecvDeactivate();
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
  private:
   ~BrowserBridgeParent();
 
-  RefPtr<TabParent> mTabParent;
+  RefPtr<BrowserParent> mBrowserParent;
   bool mIPCOpen;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // !defined(mozilla_dom_BrowserBridgeParent_h)
rename from dom/ipc/TabChild.cpp
rename to dom/ipc/BrowserChild.cpp
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/BrowserChild.cpp
@@ -1,25 +1,25 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "base/basictypes.h"
 
-#include "TabChild.h"
+#include "BrowserChild.h"
 
 #include "gfxPrefs.h"
 #ifdef ACCESSIBILITY
 #  include "mozilla/a11y/DocAccessibleChild.h"
 #endif
 #include "Layers.h"
 #include "ContentChild.h"
-#include "TabParent.h"
+#include "BrowserParent.h"
 #include "js/JSON.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/BrowserElementParent.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/DataTransfer.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/LoadURIOptionsBinding.h"
@@ -158,86 +158,87 @@ using namespace mozilla::docshell;
 using namespace mozilla::widget;
 using namespace mozilla::jsipc;
 using mozilla::layers::GeckoContentController;
 
 NS_IMPL_ISUPPORTS(ContentListener, nsIDOMEventListener)
 
 static const char BEFORE_FIRST_PAINT[] = "before-first-paint";
 
-nsTHashtable<nsPtrHashKey<TabChild>>* TabChild::sVisibleTabs;
-
-typedef nsDataHashtable<nsUint64HashKey, TabChild*> TabChildMap;
-static TabChildMap* sTabChildren;
-StaticMutex sTabChildrenMutex;
-
-TabChildBase::TabChildBase() : mTabChildMessageManager(nullptr) {}
-
-TabChildBase::~TabChildBase() { mAnonymousGlobalScopes.Clear(); }
-
-NS_IMPL_CYCLE_COLLECTION_CLASS(TabChildBase)
-
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TabChildBase)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTabChildMessageManager)
+nsTHashtable<nsPtrHashKey<BrowserChild>>* BrowserChild::sVisibleTabs;
+
+typedef nsDataHashtable<nsUint64HashKey, BrowserChild*> BrowserChildMap;
+static BrowserChildMap* sBrowserChildren;
+StaticMutex sBrowserChildrenMutex;
+
+BrowserChildBase::BrowserChildBase() : mBrowserChildMessageManager(nullptr) {}
+
+BrowserChildBase::~BrowserChildBase() { mAnonymousGlobalScopes.Clear(); }
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(BrowserChildBase)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(BrowserChildBase)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChildMessageManager)
   tmp->nsMessageManagerScriptExecutor::Unlink();
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWebBrowserChrome)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TabChildBase)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTabChildMessageManager)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(BrowserChildBase)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChildMessageManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWebBrowserChrome)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(TabChildBase)
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(BrowserChildBase)
   tmp->nsMessageManagerScriptExecutor::Trace(aCallbacks, aClosure);
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TabChildBase)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserChildBase)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(TabChildBase)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(TabChildBase)
-
-already_AddRefed<Document> TabChildBase::GetTopLevelDocument() const {
+NS_IMPL_CYCLE_COLLECTING_ADDREF(BrowserChildBase)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(BrowserChildBase)
+
+already_AddRefed<Document> BrowserChildBase::GetTopLevelDocument() const {
   nsCOMPtr<Document> doc;
   WebNavigation()->GetDocument(getter_AddRefs(doc));
   return doc.forget();
 }
 
-PresShell* TabChildBase::GetTopLevelPresShell() const {
+PresShell* BrowserChildBase::GetTopLevelPresShell() const {
   if (RefPtr<Document> doc = GetTopLevelDocument()) {
     return doc->GetPresShell();
   }
   return nullptr;
 }
 
-void TabChildBase::DispatchMessageManagerMessage(const nsAString& aMessageName,
-                                                 const nsAString& aJSONData) {
+void BrowserChildBase::DispatchMessageManagerMessage(
+    const nsAString& aMessageName, const nsAString& aJSONData) {
   AutoSafeJSContext cx;
   JS::Rooted<JS::Value> json(cx, JS::NullValue());
   dom::ipc::StructuredCloneData data;
   if (JS_ParseJSON(cx, static_cast<const char16_t*>(aJSONData.BeginReading()),
                    aJSONData.Length(), &json)) {
     ErrorResult rv;
     data.Write(cx, json, rv);
     if (NS_WARN_IF(rv.Failed())) {
       rv.SuppressException();
       return;
     }
   }
 
-  RefPtr<TabChildMessageManager> kungFuDeathGrip(mTabChildMessageManager);
+  RefPtr<BrowserChildMessageManager> kungFuDeathGrip(
+      mBrowserChildMessageManager);
   RefPtr<nsFrameMessageManager> mm = kungFuDeathGrip->GetMessageManager();
   mm->ReceiveMessage(static_cast<EventTarget*>(kungFuDeathGrip), nullptr,
                      aMessageName, false, &data, nullptr, nullptr, nullptr,
                      IgnoreErrors());
 }
 
-bool TabChildBase::UpdateFrameHandler(const RepaintRequest& aRequest) {
+bool BrowserChildBase::UpdateFrameHandler(const RepaintRequest& aRequest) {
   MOZ_ASSERT(aRequest.GetScrollId() != ScrollableLayerGuid::NULL_SCROLL_ID);
 
   if (aRequest.IsRootContent()) {
     if (PresShell* presShell = GetTopLevelPresShell()) {
       // Guard against stale updates (updates meant for a pres shell which
       // has since been torn down and destroyed).
       if (aRequest.GetPresShellId() == presShell->GetPresShellId()) {
         ProcessUpdateFrame(aRequest);
@@ -248,129 +249,130 @@ bool TabChildBase::UpdateFrameHandler(co
     // aRequest.mIsRoot is false, so we are trying to update a subframe.
     // This requires special handling.
     APZCCallbackHelper::UpdateSubFrame(aRequest);
     return true;
   }
   return true;
 }
 
-void TabChildBase::ProcessUpdateFrame(const RepaintRequest& aRequest) {
-  if (!mTabChildMessageManager) {
+void BrowserChildBase::ProcessUpdateFrame(const RepaintRequest& aRequest) {
+  if (!mBrowserChildMessageManager) {
     return;
   }
 
   APZCCallbackHelper::UpdateRootFrame(aRequest);
 }
 
 NS_IMETHODIMP
 ContentListener::HandleEvent(Event* aEvent) {
   RemoteDOMEvent remoteEvent;
   remoteEvent.mEvent = aEvent;
   NS_ENSURE_STATE(remoteEvent.mEvent);
-  mTabChild->SendEvent(remoteEvent);
+  mBrowserChild->SendEvent(remoteEvent);
   return NS_OK;
 }
 
-class TabChild::DelayedDeleteRunnable final : public Runnable,
-                                              public nsIRunnablePriority {
-  RefPtr<TabChild> mTabChild;
+class BrowserChild::DelayedDeleteRunnable final : public Runnable,
+                                                  public nsIRunnablePriority {
+  RefPtr<BrowserChild> mBrowserChild;
 
   // In order to ensure that this runnable runs after everything that could
   // possibly touch this tab, we send it through the event queue twice. The
   // first time it runs at normal priority and the second time it runs at
   // input priority. This ensures that it runs after all events that were in
   // either queue at the time it was first dispatched. mReadyToDelete starts
   // out false (when it runs at normal priority) and is then set to true.
   bool mReadyToDelete = false;
 
  public:
-  explicit DelayedDeleteRunnable(TabChild* aTabChild)
-      : Runnable("TabChild::DelayedDeleteRunnable"), mTabChild(aTabChild) {
+  explicit DelayedDeleteRunnable(BrowserChild* aBrowserChild)
+      : Runnable("BrowserChild::DelayedDeleteRunnable"),
+        mBrowserChild(aBrowserChild) {
     MOZ_ASSERT(NS_IsMainThread());
-    MOZ_ASSERT(aTabChild);
+    MOZ_ASSERT(aBrowserChild);
   }
 
   NS_DECL_ISUPPORTS_INHERITED
 
  private:
   ~DelayedDeleteRunnable() {
     MOZ_ASSERT(NS_IsMainThread());
-    MOZ_ASSERT(!mTabChild);
+    MOZ_ASSERT(!mBrowserChild);
   }
 
   NS_IMETHOD GetPriority(uint32_t* aPriority) override {
     *aPriority = mReadyToDelete ? nsIRunnablePriority::PRIORITY_INPUT
                                 : nsIRunnablePriority::PRIORITY_NORMAL;
     return NS_OK;
   }
 
   NS_IMETHOD
   Run() override {
     MOZ_ASSERT(NS_IsMainThread());
-    MOZ_ASSERT(mTabChild);
+    MOZ_ASSERT(mBrowserChild);
 
     if (!mReadyToDelete) {
       // This time run this runnable at input priority.
       mReadyToDelete = true;
       MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(this));
       return NS_OK;
     }
 
     // Check in case ActorDestroy was called after RecvDestroy message.
     // Middleman processes with their own recording child process avoid
     // sending a delete message, so that the parent process does not
     // receive two deletes for the same actor.
-    if (mTabChild->IPCOpen() &&
+    if (mBrowserChild->IPCOpen() &&
         !recordreplay::parent::IsMiddlemanWithRecordingChild()) {
-      Unused << PBrowserChild::Send__delete__(mTabChild);
+      Unused << PBrowserChild::Send__delete__(mBrowserChild);
     }
 
-    mTabChild = nullptr;
+    mBrowserChild = nullptr;
     return NS_OK;
   }
 };
 
-NS_IMPL_ISUPPORTS_INHERITED(TabChild::DelayedDeleteRunnable, Runnable,
+NS_IMPL_ISUPPORTS_INHERITED(BrowserChild::DelayedDeleteRunnable, Runnable,
                             nsIRunnablePriority)
 
 namespace {
-std::map<TabId, RefPtr<TabChild>>& NestedTabChildMap() {
+std::map<TabId, RefPtr<BrowserChild>>& NestedBrowserChildMap() {
   MOZ_ASSERT(NS_IsMainThread());
-  static std::map<TabId, RefPtr<TabChild>> sNestedTabChildMap;
-  return sNestedTabChildMap;
+  static std::map<TabId, RefPtr<BrowserChild>> sNestedBrowserChildMap;
+  return sNestedBrowserChildMap;
 }
 }  // namespace
 
-already_AddRefed<TabChild> TabChild::FindTabChild(const TabId& aTabId) {
-  auto iter = NestedTabChildMap().find(aTabId);
-  if (iter == NestedTabChildMap().end()) {
+already_AddRefed<BrowserChild> BrowserChild::FindBrowserChild(
+    const TabId& aTabId) {
+  auto iter = NestedBrowserChildMap().find(aTabId);
+  if (iter == NestedBrowserChildMap().end()) {
     return nullptr;
   }
-  RefPtr<TabChild> tabChild = iter->second;
-  return tabChild.forget();
+  RefPtr<BrowserChild> browserChild = iter->second;
+  return browserChild.forget();
 }
 
 /*static*/
-already_AddRefed<TabChild> TabChild::Create(ContentChild* aManager,
-                                            const TabId& aTabId,
-                                            const TabId& aSameTabGroupAs,
-                                            const TabContext& aContext,
-                                            BrowsingContext* aBrowsingContext,
-                                            uint32_t aChromeFlags) {
-  RefPtr<TabChild> groupChild = FindTabChild(aSameTabGroupAs);
+already_AddRefed<BrowserChild> BrowserChild::Create(
+    ContentChild* aManager, const TabId& aTabId, const TabId& aSameTabGroupAs,
+    const TabContext& aContext, BrowsingContext* aBrowsingContext,
+    uint32_t aChromeFlags) {
+  RefPtr<BrowserChild> groupChild = FindBrowserChild(aSameTabGroupAs);
   dom::TabGroup* group = groupChild ? groupChild->TabGroup() : nullptr;
-  RefPtr<TabChild> iframe = new TabChild(aManager, aTabId, group, aContext,
-                                         aBrowsingContext, aChromeFlags);
+  RefPtr<BrowserChild> iframe = new BrowserChild(
+      aManager, aTabId, group, aContext, aBrowsingContext, aChromeFlags);
   return iframe.forget();
 }
 
-TabChild::TabChild(ContentChild* aManager, const TabId& aTabId,
-                   dom::TabGroup* aTabGroup, const TabContext& aContext,
-                   BrowsingContext* aBrowsingContext, uint32_t aChromeFlags)
+BrowserChild::BrowserChild(ContentChild* aManager, const TabId& aTabId,
+                           dom::TabGroup* aTabGroup, const TabContext& aContext,
+                           BrowsingContext* aBrowsingContext,
+                           uint32_t aChromeFlags)
     : TabContext(aContext),
       mTabGroup(aTabGroup),
       mManager(aManager),
       mBrowsingContext(aBrowsingContext),
       mChromeFlags(aChromeFlags),
       mMaxTouchPoints(0),
       mLayersId{0},
       mBeforeUnloadListeners(0),
@@ -403,56 +405,57 @@ TabChild::TabChild(ContentChild* aManage
         ,
     mPendingDocShellIsActive(false), mPendingDocShellReceivedMessage(false),
     mPendingRenderLayers(false),
     mPendingRenderLayersReceivedMessage(false), mPendingLayersObserverEpoch{0},
     mPendingDocShellBlockers(0), mWidgetNativeData(0) {
   mozilla::HoldJSObjects(this);
 
   nsWeakPtr weakPtrThis(do_GetWeakReference(
-      static_cast<nsITabChild*>(this)));  // for capture by the lambda
+      static_cast<nsIBrowserChild*>(this)));  // for capture by the lambda
   mSetAllowedTouchBehaviorCallback =
       [weakPtrThis](uint64_t aInputBlockId,
                     const nsTArray<TouchBehaviorFlags>& aFlags) {
-        if (nsCOMPtr<nsITabChild> tabChild = do_QueryReferent(weakPtrThis)) {
-          static_cast<TabChild*>(tabChild.get())
+        if (nsCOMPtr<nsIBrowserChild> browserChild =
+                do_QueryReferent(weakPtrThis)) {
+          static_cast<BrowserChild*>(browserChild.get())
               ->SetAllowedTouchBehavior(aInputBlockId, aFlags);
         }
       };
 
-  // preloaded TabChild should not be added to child map
+  // preloaded BrowserChild should not be added to child map
   if (mUniqueId) {
-    MOZ_ASSERT(NestedTabChildMap().find(mUniqueId) ==
-               NestedTabChildMap().end());
-    NestedTabChildMap()[mUniqueId] = this;
+    MOZ_ASSERT(NestedBrowserChildMap().find(mUniqueId) ==
+               NestedBrowserChildMap().end());
+    NestedBrowserChildMap()[mUniqueId] = this;
   }
   mCoalesceMouseMoveEvents =
       Preferences::GetBool("dom.event.coalesce_mouse_move");
   if (mCoalesceMouseMoveEvents) {
     mCoalescedMouseEventFlusher = new CoalescedMouseMoveFlusher(this);
   }
 }
 
-const CompositorOptions& TabChild::GetCompositorOptions() const {
+const CompositorOptions& BrowserChild::GetCompositorOptions() const {
   // If you're calling this before mCompositorOptions is set, well.. don't.
   MOZ_ASSERT(mCompositorOptions);
   return mCompositorOptions.ref();
 }
 
-bool TabChild::AsyncPanZoomEnabled() const {
+bool BrowserChild::AsyncPanZoomEnabled() const {
   // This might get called by the TouchEvent::PrefEnabled code before we have
   // mCompositorOptions populated (bug 1370089). In that case we just assume
-  // APZ is enabled because we're in a content process (because TabChild) and
-  // APZ is probably going to be enabled here since e10s is enabled.
+  // APZ is enabled because we're in a content process (because BrowserChild)
+  // and APZ is probably going to be enabled here since e10s is enabled.
   return mCompositorOptions ? mCompositorOptions->UseAPZ() : true;
 }
 
 NS_IMETHODIMP
-TabChild::Observe(nsISupports* aSubject, const char* aTopic,
-                  const char16_t* aData) {
+BrowserChild::Observe(nsISupports* aSubject, const char* aTopic,
+                      const char16_t* aData) {
   if (!strcmp(aTopic, BEFORE_FIRST_PAINT)) {
     if (AsyncPanZoomEnabled()) {
       nsCOMPtr<Document> subject(do_QueryInterface(aSubject));
       nsCOMPtr<Document> doc(GetTopLevelDocument());
 
       if (subject == doc) {
         RefPtr<PresShell> presShell = doc->GetPresShell();
         if (presShell) {
@@ -462,55 +465,55 @@ TabChild::Observe(nsISupports* aSubject,
         APZCCallbackHelper::InitializeRootDisplayport(presShell);
       }
     }
   }
 
   return NS_OK;
 }
 
-void TabChild::ContentReceivedInputBlock(const ScrollableLayerGuid& aGuid,
-                                         uint64_t aInputBlockId,
-                                         bool aPreventDefault) const {
+void BrowserChild::ContentReceivedInputBlock(const ScrollableLayerGuid& aGuid,
+                                             uint64_t aInputBlockId,
+                                             bool aPreventDefault) const {
   if (mApzcTreeManager) {
     mApzcTreeManager->ContentReceivedInputBlock(aInputBlockId, aPreventDefault);
   }
 }
 
-void TabChild::SetTargetAPZC(
+void BrowserChild::SetTargetAPZC(
     uint64_t aInputBlockId,
     const nsTArray<SLGuidAndRenderRoot>& aTargets) const {
   if (mApzcTreeManager) {
     mApzcTreeManager->SetTargetAPZC(aInputBlockId, aTargets);
   }
 }
 
-void TabChild::SetAllowedTouchBehavior(
+void BrowserChild::SetAllowedTouchBehavior(
     uint64_t aInputBlockId,
     const nsTArray<TouchBehaviorFlags>& aTargets) const {
   if (mApzcTreeManager) {
     mApzcTreeManager->SetAllowedTouchBehavior(aInputBlockId, aTargets);
   }
 }
 
-bool TabChild::DoUpdateZoomConstraints(
+bool BrowserChild::DoUpdateZoomConstraints(
     const uint32_t& aPresShellId, const ViewID& aViewId,
     const Maybe<ZoomConstraints>& aConstraints) {
   if (!mApzcTreeManager || mDestroyed) {
     return false;
   }
 
   SLGuidAndRenderRoot guid = SLGuidAndRenderRoot(
       mLayersId, aPresShellId, aViewId, gfxUtils::GetContentRenderRoot());
 
   mApzcTreeManager->UpdateZoomConstraints(guid, aConstraints);
   return true;
 }
 
-nsresult TabChild::Init(mozIDOMWindowProxy* aParent) {
+nsresult BrowserChild::Init(mozIDOMWindowProxy* aParent) {
   MOZ_DIAGNOSTIC_ASSERT(mTabGroup);
 
   nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(this);
   mPuppetWidget = static_cast<PuppetWidget*>(widget.get());
   if (!mPuppetWidget) {
     NS_ERROR("couldn't create fake widget");
     return NS_ERROR_FAILURE;
   }
@@ -586,39 +589,40 @@ nsresult TabChild::Init(mozIDOMWindowPro
     window->SetInitialKeyboardIndicators(ShowAccelerators(), ShowFocusRings());
   }
 
   nsContentUtils::SetScrollbarsVisibility(
       window->GetDocShell(),
       !!(mChromeFlags & nsIWebBrowserChrome::CHROME_SCROLLBARS));
 
   nsWeakPtr weakPtrThis = do_GetWeakReference(
-      static_cast<nsITabChild*>(this));  // for capture by the lambda
+      static_cast<nsIBrowserChild*>(this));  // for capture by the lambda
   ContentReceivedInputBlockCallback callback(
       [weakPtrThis](const ScrollableLayerGuid& aGuid, uint64_t aInputBlockId,
                     bool aPreventDefault) {
-        if (nsCOMPtr<nsITabChild> tabChild = do_QueryReferent(weakPtrThis)) {
-          static_cast<TabChild*>(tabChild.get())
+        if (nsCOMPtr<nsIBrowserChild> browserChild =
+                do_QueryReferent(weakPtrThis)) {
+          static_cast<BrowserChild*>(browserChild.get())
               ->ContentReceivedInputBlock(aGuid, aInputBlockId,
                                           aPreventDefault);
         }
       });
   mAPZEventState = new APZEventState(mPuppetWidget, std::move(callback));
 
   mIPCOpen = true;
 
   // Recording/replaying processes use their own compositor.
   if (recordreplay::IsRecordingOrReplaying()) {
     mPuppetWidget->CreateCompositor();
   }
 
   return NS_OK;
 }
 
-void TabChild::NotifyTabContextUpdated(bool aIsPreallocated) {
+void BrowserChild::NotifyTabContextUpdated(bool aIsPreallocated) {
   nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
   MOZ_ASSERT(docShell);
 
   if (!docShell) {
     return;
   }
 
   UpdateFrameType();
@@ -628,85 +632,87 @@ void TabChild::NotifyTabContextUpdated(b
   }
 
   // Set SANDBOXED_AUXILIARY_NAVIGATION flag if this is a receiver page.
   if (!PresentationURL().IsEmpty()) {
     docShell->SetSandboxFlags(SANDBOXED_AUXILIARY_NAVIGATION);
   }
 }
 
-void TabChild::UpdateFrameType() {
+void BrowserChild::UpdateFrameType() {
   nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
   MOZ_ASSERT(docShell);
 
   // TODO: Bug 1252794 - remove frameType from nsIDocShell.idl
   docShell->SetFrameType(IsMozBrowserElement()
                              ? nsIDocShell::FRAME_TYPE_BROWSER
                              : nsIDocShell::FRAME_TYPE_REGULAR);
 }
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(TabChild)
-
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(TabChild, TabChildBase)
+NS_IMPL_CYCLE_COLLECTION_CLASS(BrowserChild)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(BrowserChild, BrowserChildBase)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStatusFilter)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWebNav)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowsingContext)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(TabChild, TabChildBase)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(BrowserChild,
+                                                  BrowserChildBase)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStatusFilter)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWebNav)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowsingContext)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(TabChild, TabChildBase)
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(BrowserChild, BrowserChildBase)
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TabChild)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserChild)
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome)
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome2)
   NS_INTERFACE_MAP_ENTRY(nsIEmbeddingSiteWindow)
   NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChromeFocus)
   NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
   NS_INTERFACE_MAP_ENTRY(nsIWindowProvider)
-  NS_INTERFACE_MAP_ENTRY(nsITabChild)
+  NS_INTERFACE_MAP_ENTRY(nsIBrowserChild)
   NS_INTERFACE_MAP_ENTRY(nsIObserver)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
   NS_INTERFACE_MAP_ENTRY(nsITooltipListener)
   NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
-NS_INTERFACE_MAP_END_INHERITING(TabChildBase)
-
-NS_IMPL_ADDREF_INHERITED(TabChild, TabChildBase);
-NS_IMPL_RELEASE_INHERITED(TabChild, TabChildBase);
+NS_INTERFACE_MAP_END_INHERITING(BrowserChildBase)
+
+NS_IMPL_ADDREF_INHERITED(BrowserChild, BrowserChildBase);
+NS_IMPL_RELEASE_INHERITED(BrowserChild, BrowserChildBase);
 
 NS_IMETHODIMP
-TabChild::SetStatus(uint32_t aStatusType, const char16_t* aStatus) {
+BrowserChild::SetStatus(uint32_t aStatusType, const char16_t* aStatus) {
   return SetStatusWithContext(
       aStatusType,
       aStatus ? static_cast<const nsString&>(nsDependentString(aStatus))
               : EmptyString(),
       nullptr);
 }
 
 NS_IMETHODIMP
-TabChild::GetChromeFlags(uint32_t* aChromeFlags) {
+BrowserChild::GetChromeFlags(uint32_t* aChromeFlags) {
   *aChromeFlags = mChromeFlags;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-TabChild::SetChromeFlags(uint32_t aChromeFlags) {
+BrowserChild::SetChromeFlags(uint32_t aChromeFlags) {
   NS_WARNING("trying to SetChromeFlags from content process?");
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-TabChild::RemoteSizeShellTo(int32_t aWidth, int32_t aHeight,
-                            int32_t aShellItemWidth, int32_t aShellItemHeight) {
+BrowserChild::RemoteSizeShellTo(int32_t aWidth, int32_t aHeight,
+                                int32_t aShellItemWidth,
+                                int32_t aShellItemHeight) {
   nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
   nsCOMPtr<nsIBaseWindow> docShellAsWin(do_QueryInterface(ourDocShell));
   NS_ENSURE_STATE(docShellAsWin);
 
   int32_t width, height;
   docShellAsWin->GetSize(&width, &height);
 
   uint32_t flags = 0;
@@ -720,17 +726,18 @@ TabChild::RemoteSizeShellTo(int32_t aWid
 
   bool sent = SendSizeShellTo(flags, aWidth, aHeight, aShellItemWidth,
                               aShellItemHeight);
 
   return sent ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-TabChild::RemoteDropLinks(uint32_t aLinksCount, nsIDroppedLinkItem** aLinks) {
+BrowserChild::RemoteDropLinks(uint32_t aLinksCount,
+                              nsIDroppedLinkItem** aLinks) {
   nsTArray<nsString> linksArray;
   nsresult rv = NS_OK;
   for (uint32_t i = 0; i < aLinksCount; i++) {
     nsString tmp;
     rv = aLinks[i]->GetUrl(tmp);
     if (NS_FAILED(rv)) {
       return rv;
     }
@@ -749,42 +756,42 @@ TabChild::RemoteDropLinks(uint32_t aLink
     linksArray.AppendElement(tmp);