| blob | a611511630436c7a89db01dad627174f47e1af38 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #ifdef MOZ_WIDGET_ANDROID
9 #endif
111 #ifdef NS_PRINTING
113 #endif
143 #if defined(MOZ_SANDBOX)
145 # if defined(XP_WIN)
148 # elif defined(XP_LINUX)
153 # elif defined(XP_MACOSX)
154 # include <CoreGraphics/CGError.h>
156 # elif defined(__OpenBSD__)
157 # include <err.h>
158 # include <sys/stat.h>
159 # include <unistd.h>
161 # include <fstream>
167 # endif
168 # if defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
170 # endif
171 #endif
219 #ifdef MOZ_WEBRTC
221 #endif
227 #if defined(MOZ_WIDGET_ANDROID)
229 # include <sched.h>
230 #endif
232 #ifdef XP_WIN
233 # include <process.h>
234 # define getpid _getpid
236 #endif
238 #if defined(XP_MACOSX)
240 # include <sys/qos.h>
243 #ifdef MOZ_X11
245 #endif
247 #ifdef ACCESSIBILITY
249 # ifdef XP_WIN
251 # endif
255 #endif
260 #ifdef MOZ_WEBSPEECH
262 #endif
285 #ifdef MOZ_WIDGET_GTK
288 # include <gtk/gtk.h>
289 #endif
291 #ifdef MOZ_CODE_COVERAGE
293 #endif
315 }
321 }
328 "This is a notification of the priority change "
333 }
334 };
339 }
347 }
355 }
356 };
362 // IPC sender for remote GC/CC logging.
368 NS_DECL_ISUPPORTS
375 }
380 }
384 }
392 }
400 }
404 }
408 }
412 }
416 }
420 }
424 }
431 }
435 }
436 // The XPCOM refcount drives the IPC lifecycle;
438 }
442 "This object is a remote GC/CC logger;"
445 }
450 };
454 };
462 NS_DECL_ISUPPORTS
463 NS_DECL_NSICONSOLELISTENER
470 };
474 // Before we send the error to the parent process (which
475 // involves copying the memory), truncate any long lines. CSS
476 // errors in particular share the memory for long lines with
477 // repeated errors, but the IPC communication we're about to do
478 // will break that sharing, so we better truncate now.
483 }
484 }
486 NS_IMETHODIMP
490 }
494 nsAutoString msg;
495 nsAutoCString sourceName;
496 nsCString category;
520 {
521 AutoJSAPI jsapi;
530 // Because |stack| might be a cross-compartment wrapper, we can't use it
531 // with JSAutoRealm. Use the stackGlobal for that.
538 StructuredCloneData data;
539 ErrorResult err;
543 }
545 ClonedMessageData cloned;
548 }
554 }
555 }
560 }
562 nsString msg;
567 }
569 #ifdef NIGHTLY_BUILD
570 /**
571 * The singleton of this class is registered with the BackgroundHangMonitor as
572 * an annotator, so that the hang monitor can record whether or not there were
573 * pending input events when the thread hung.
574 */
581 }
582 }
585 };
587 #endif
596 // This process is a content process, so it's clearly running in
597 // multiprocess mode!
600 // Our static analysis doesn't allow capturing ref-counted pointers in
601 // lambdas, so we need to hide it in a uintptr_t. This is safe because this
602 // lambda will be destroyed in ~ContentChild().
613 aProfilingState);
614 },
615 self);
617 // When ContentChild is created, the observer service does not even exist.
618 // When ContentChild::RecvSetXPCOMProcessAttributes is called (the first
619 // IPDL call made on this object), shutdown may have already happened. Thus
620 // we create a canary here that relies upon getting cleared if shutdown
621 // happens without requiring the observer service at this time.
625 }
626 }
628 #ifdef _MSC_VER
629 # pragma warning(push)
630 # pragma warning( \
632 */
633 #endif
638 #ifndef NS_FREE_PERMANENT_DATA
640 #endif
641 }
643 #ifdef _MSC_VER
644 # pragma warning(pop)
645 #endif
650 NS_INTERFACE_MAP_END
661 }
671 aIsReadyForBackgroundProcessing);
679 }
681 }
690 }
691 };
695 #ifdef MOZ_WIDGET_GTK
696 // When running X11 only build we need to pass a display down
697 // to gtk_init because it's not going to use the one from the environment
698 // on its own when deciding which backend to use, and when starting under
699 // XWayland, it may choose to start with the wayland backend
700 // instead of the x11 backend.
701 // The DISPLAY environment variable is normally set by the parent process.
702 // The MOZ_GDK_DISPLAY environment variable is set from nsAppRunner.cpp
703 // when --display is set by the command line.
708 # ifdef MOZ_WAYLAND
710 # endif
713 }
714 }
719 // argv0 is unused because g_set_prgname() was called in
720 // XRE_InitChildProcess().
726 }
727 }
728 #endif
730 #ifdef MOZ_X11
732 // Do this after initializing GDK, or GDK will install its own handler.
734 }
735 #endif
739 // Once we start sending IPC messages, we need the thread manager to be
740 // initialized so we can deal with the responses. Do that here before we
741 // try to construct the crash reporter.
745 }
749 }
752 // If communications with the parent have broken down, take the process
753 // down so it's not hanging around.
756 // This must be checked before any IPDL message, which may hit sentinel
757 // errors due to parent and content processes having different
758 // versions.
761 // We need to quit this process if the buildID doesn't match the parent's.
762 // This can occur when an update occurred in the background.
764 }
766 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
768 #endif
770 #ifdef MOZ_X11
771 # ifdef MOZ_WIDGET_GTK
773 // Send the parent our X socket to act as a proxy reference for our X
774 // resources.
777 }
778 # endif
779 #endif
787 #ifdef NIGHTLY_BUILD
788 // NOTE: We have to register the annotator on the main thread, as annotators
789 // only affect a single thread.
794 }));
795 #endif
797 #if defined(MOZ_MEMORY) && defined(DEBUG) && !defined(MOZ_UBSAN)
798 jemalloc_stats_t stats;
802 #endif
803 }
811 }
812 }
815 }
822 #ifdef XP_UNIX
826 #elif defined(XP_WIN)
827 // Windows has a decent JIT debugging story, so NS_DebugBreak does the
828 // right thing.
832 #endif
833 }
839 }
843 // Requires pref flip
848 // DEFAULT_PRIVATE_BROWSING_ID is the value when it's not private
854 #ifdef NIGHTLY_BUILD
855 // Nightly can show site names for private windows, with a second pref
857 #endif
858 ) {
859 #if !defined(XP_MACOSX)
860 // Mac doesn't have the 15-character limit Linux does
861 // Sets profiler process name
863 nsAutoCString schemeless;
865 nsAutoCString originSuffix;
870 #endif
871 {
873 }
874 }
875 }
876 }
881 }
883 // else private window, don't change process name, or the pref isn't set
884 // mProcessName is always flat (mProcessName == aName)
891 }
902 }
907 }
912 }
915 }
925 }
930 }
938 }
944 }
948 }
952 }
967 nsresult rv;
972 // Block the attempt to open a new window if the opening BrowsingContext is
973 // not marked to use remote tabs. This ensures that the newly opened window is
974 // correctly remote.
977 }
986 }
989 // Certain conditions complicate the process of creating the new
990 // BrowsingContext, and prevent us from using the
991 // "CreateWindowInDifferentProcess" codepath.
992 // * With Fission enabled, process selection will happen during the load, so
993 // switching processes eagerly will not provide a benefit.
994 // * Windows created for printing must be created within the current process
995 // so that a static clone of the source document can be created.
996 // * Sandboxed popups require the full window creation codepath.
997 // * Loads with form or POST data require the full window creation codepath.
1001 SANDBOX_PROPAGATES_TO_AUXILIARY_BROWSING_CONTEXTS) ||
1005 // If we're in a content process and we have noopener set, there's no reason
1006 // to load in our process, so let's load it elsewhere!
1019 }
1023 }
1030 }
1033 }
1035 }();
1040 }
1043 }
1052 textDirectiveUserActivation);
1054 // We return NS_ERROR_ABORT, so that the caller knows that we've abandoned
1055 // the window open as far as it is concerned.
1057 }
1058 }
1062 // We need to assign a TabGroup to the PBrowser actor before we send it to the
1063 // parent. Otherwise, the parent could send messages to us before we have a
1064 // proper TabGroup for that actor.
1068 }
1076 });
1085 });
1089 // The initial about:blank document we generate within the nsDocShell will
1090 // almost certainly be replaced at some point. Unfortunately, getting the
1091 // principal right here causes bugs due to frame scripts not getting events
1092 // they expect, due to the real initial about:blank not being created yet.
1093 //
1094 // For this reason, we intentionally mispredict the initial principal here, so
1095 // that we can act the same as we did before when not predicting a result
1096 // principal. This `PWindowGlobal` will almost immediately be destroyed.
1106 }
1114 }
1116 // Open a remote endpoint for our PBrowser actor.
1120 }
1122 // Open a remote endpoint for our PWindowGlobal actor.
1127 }
1129 // Tell the parent process to set up its PBrowserParent.
1135 }
1141 }
1142 });
1144 // Now that |newChild| has had its IPC link established, call |Init| to set it
1145 // up.
1146 // XXX: This MOZ_KnownLive is only necessary because the static analysis can't
1147 // tell that NotNull<RefPtr<BrowserChild>> is a strong pointer.
1152 }
1154 // Set to true when we're ready to return from this function.
1157 // NOTE: Capturing by reference here is safe, as this function won't return
1158 // until one of these callbacks is called.
1167 // Once this function exits, we should try to exit the nested event loop.
1170 // NOTE: We have to handle this immediately in the resolve callback in order
1171 // to make sure that we don't process any more IPC messages before returning
1172 // from ProvideWindowCommon.
1174 // Handle the error which we got back from the parent process, if we got
1175 // one.
1178 }
1183 }
1185 // If the BrowserChild has been torn down, we don't need to do this anymore.
1189 }
1207 }
1209 // Unfortunately we don't get a window unless we've shown the frame. That's
1210 // pretty bogus; see bug 763602.
1220 }
1221 }
1229 }
1230 }
1233 };
1235 // NOTE: Capturing by reference here is safe, as this function won't return
1236 // until one of these callbacks is called.
1242 };
1244 // Send down the request to open the window.
1254 }
1267 // =======================
1268 // Begin Nested Event Loop
1269 // =======================
1271 // We have to wait for a response from SendCreateWindow or with information
1272 // we're going to need to return from this function, So we spin a nested event
1273 // loop until they get back to us.
1275 {
1276 // Suppress event handling for all contexts in our BrowsingContextGroup so
1277 // that event handlers cannot target our new window while it's still being
1278 // opened. Note that pending events that were suppressed while our blocker
1279 // was active will be dispatched asynchronously from a runnable dispatched
1280 // to the main event loop after this function returns, not immediately when
1281 // we leave this scope.
1284 AutoNoJSAPI nojsapi;
1286 // Spin the event loop until we get a response. Callers of this function
1287 // already have to guard against an inner event loop spinning in the
1288 // non-e10s case because of the need to spin one to create a new chrome
1289 // window.
1293 "We are on the main thread, so we should not exit this "
1295 }
1297 // =====================
1298 // End Nested Event Loop
1299 // =====================
1301 // It's possible for our new BrowsingContext to become discarded during the
1302 // nested event loop, in which case we shouldn't return it, since our callers
1303 // will generally not be prepared to deal with that.
1307 }
1309 // We should have the results already set by the callbacks.
1312 }
1320 }
1322 /* static */
1326 }
1329 }
1333 }
1341 }
1343 // Map the shared memory storing the user agent style sheets. Do this as
1344 // early as possible to maximize the chance of being able to map at the
1345 // address we want.
1347 }
1353 #ifdef MOZ_WIDGET_GTK
1354 // LookAndFeel::NativeInit takes a long time to run on Linux, here we schedule
1355 // it as soon as possible after BackgroundChild::Startup to give
1356 // it chance to run ahead of ConstructBrowser
1359 #endif
1361 #if defined(XP_WIN)
1362 // DLL services untrusted modules processing depends on
1363 // BackgroundChild::Startup having been called
1372 }
1376 // RemoteWorkerService will be initialized in RecvRemoteType, to avoid to
1377 // register it to the RemoteWorkerManager while it is still a prealloc
1378 // remoteType and defer it to the point the child process is assigned a.
1379 // actual remoteType.
1385 }
1413 }
1415 }
1422 }
1424 {
1425 AutoJSAPI jsapi;
1428 }
1429 ErrorResult rv;
1436 }
1439 }
1441 // The stylesheet cache is not ready yet. Store this URL for future use.
1447 // Initialize the RemoteDecoderManager thread and its associated PBackground
1448 // channel.
1452 kFissionEnforceBlockList);
1454 kFissionOmitBlockListValues);
1456 // Set the dynamic scalar definitions for this process.
1458 }
1465 nsCString process;
1470 }
1478 },
1479 aResolver);
1481 }
1483 #if defined(XP_WIN)
1491 },
1494 }
1500 }
1502 }
1509 }
1514 // The sink's destructor is called when the last reference goes away, which
1515 // will cause the actor to be closed down.
1520 // Invoke the dumper, which will take a reference to the sink.
1525 }
1532 }
1538 }
1540 }
1546 }
1552 }
1558 }
1561 GeckoChildID aOtherChildID) {
1563 // If we are talking to ourselves, or the UI process, then that is a fatal
1564 // protocol error.
1566 }
1568 // If we are talking to the GPU process, then we should recover from this on
1569 // the next ContentChild::RecvReinitRendering call.
1572 }
1574 #if defined(XP_MACOSX)
1577 };
1578 #endif
1588 // Note that for all of the methods below, if it can fail, it should only
1589 // return false if the failure is an IPDL error. In such situations,
1590 // ContentChild can reason about whether or not to wait for
1591 // RecvReinitRendering (because we surmised the GPU process crashed), or if it
1592 // should crash itself (because we are actually talking to the UI process). If
1593 // there are localized failures (e.g. failed to spawn a thread), then it
1594 // should MOZ_RELEASE_ASSERT or MOZ_CRASH as necessary instead.
1597 }
1600 }
1604 }
1607 }
1610 #if defined(XP_MACOSX) && !defined(MOZ_SANDBOX)
1611 // Close all current connections to the WindowServer. This ensures that the
1612 // Activity Monitor will not label the content process as "Not responding"
1613 // because it's not running a native event loop. See bug 1384336. When the
1614 // build is configured with sandbox support, this is called during sandbox
1615 // setup.
1617 #endif
1620 }
1631 // Re-establish singleton bridges to the compositor.
1634 }
1637 }
1641 }
1644 }
1647 // Establish new PLayerTransactions.
1651 }
1652 }
1654 // Notify any observers that the compositor has been reinitialized,
1655 // eg the ZoomConstraintsClients for documents in this process.
1656 // This must occur after the ReinitRendering call above so that the
1657 // APZCTreeManagers have been connected.
1662 }
1666 }
1675 }
1676 }
1678 }
1680 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
1683 };
1686 // Close all current connections to the WindowServer. This ensures that the
1687 // Activity Monitor will not label the content process as "Not responding"
1688 // because it's not running a native event loop. See bug 1384336.
1689 // This is required with or without the sandbox enabled. Until the
1690 // window server is blocked as the policy level, this should be called
1691 // just before CGSSetDenyWindowServerConnections() so there are no
1692 // windowserver connections active when CGSSetDenyWindowServerConnections()
1693 // is called.
1696 // Actual security benefits are only achieved when we additionally deny
1697 // future connections using the sandbox policy. WebGL must be remoted if
1698 // the windowserver connections are blocked. WebGL remoting is disabled
1699 // for some tests.
1706 # if !MOZ_DIAGNOSTIC_ASSERT_ENABLED
1708 # endif
1709 }
1710 }
1711 #endif
1715 // We may want to move the sandbox initialization somewhere else
1716 // at some point; see bug 880808.
1717 #if defined(MOZ_SANDBOX)
1720 # if defined(XP_LINUX)
1721 // On Linux, we have to support systems that can't use any sandboxing.
1725 // Pre-start audio before sandboxing; see bug 1443612.
1727 }
1733 }
1734 # elif defined(XP_WIN)
1736 // Libraries required by Network Security Services (NSS).
1739 // Cache value that is retrieved from a registry entry.
1741 }
1743 # elif defined(XP_MACOSX)
1746 # endif
1750 # if defined(XP_LINUX) && !defined(ANDROID)
1758 }
1762 // bidi is always of type PuppetBidiKeyboard* (because in the child, the only
1763 // possible implementation of nsIBidiKeyboard is PuppetBidiKeyboard).
1768 }
1770 }
1779 }
1800 }
1801 }
1811 // Recover if the BrowsingContext is missing for a new subframe. The
1812 // `ManagedEndpoint` instances will be automatically destroyed.
1815 }
1817 // (these are the only possible values of `reason` at this point)
1818 return browsingContext
1821 }
1826 nsAutoCString idString;
1829 idString))) {
1835 }
1836 }
1837 }
1842 "Logic in CreateDocumentViewerForActor currently requires "
1844 }
1846 // We'll happily accept any kind of IPCTabContext here; we don't need to
1847 // check that it's of a certain type for security purposes, because we
1848 // believe whatever the parent process tells us.
1856 }
1862 }
1868 // Bind the created BrowserChild to IPC to actually link the actor.
1871 }
1874 windowChild))) {
1876 }
1881 }
1882 });
1884 // Ensure that a BrowsingContext is set for our BrowserChild before
1885 // running `Init`.
1892 }
1898 }
1899 // Notify parent that we are ready to handle input events.
1902 }
1907 }
1912 "Default Constructor for PRemoteSpellcheckEngineChild should never be "
1915 }
1921 }
1928 }
1935 }
1940 }
1946 }
1950 }
1955 }
1962 }
1967 }
1972 }
1980 }
1984 // Some scripts listen for "app-startup" to start. However, in the content
1985 // process, this category runs before the ScriptPreloader is initialized so
1986 // these scripts wouldn't be added to the cache. Instead, if a script needs to
1987 // run on start up in the content process, it should listen for this category.
1992 }
2001 }
2003 }
2008 }
2011 #ifdef NS_PRINTING
2013 #else
2015 #endif
2016 }
2020 }
2024 }
2028 }
2034 }
2036 #ifdef MOZ_WEBRTC
2040 }
2045 }
2046 #endif
2058 }
2060 reset);
2062 }
2071 }
2088 }
2091 }
2098 }
2106 }
2115 }
2119 }
2129 }
2138 }
2147 }
2158 }
2165 }
2172 }
2181 }
2183 }
2186 #if defined(XP_LINUX) && defined(MOZ_SANDBOX)
2188 #endif
2193 }
2198 }
2200 #ifndef NS_FREE_PERMANENT_DATA
2201 // In release builds, there's no point in the content process
2202 // going through the full XPCOM shutdown path, because it doesn't
2203 // keep persistent state.
2205 #else
2206 // Destroy our JSProcessActors, and reject any pending queries.
2209 # if defined(XP_WIN)
2217 }
2231 }
2232 }
2239 }
2256 }
2262 }
2267 }
2272 }
2278 }
2284 }
2292 }
2299 }
2304 }
2308 }
2310 }
2317 }
2324 }
2326 }
2337 StructuredCloneData data;
2341 }
2343 }
2353 }
2356 }
2363 }
2369 }
2377 }
2383 mSharedData =
2386 }
2389 }
2395 }
2403 }
2411 }
2414 }
2422 }
2425 }
2432 }
2439 }
2441 }
2447 }
2449 }
2457 }
2459 }
2465 }
2471 }
2476 }
2487 // note we do not need to force mUserContextId to the default here because
2488 // the permission manager does that internally.
2489 nsAutoCString originNoSuffix;
2490 OriginAttributes attrs;
2501 // child processes don't care about modification time.
2510 }
2522 }
2528 }
2530 }
2533 #ifdef ACCESSIBILITY
2534 // Start accessibility in content process if it's running in chrome
2535 // process.
2539 }
2542 #ifdef ACCESSIBILITY
2543 // Try to shutdown accessibility in content process if it's shutting down in
2544 // chrome process.
2546 #endif
2548 }
2552 #ifdef ACCESSIBILITY
2556 }
2558 #endif
2560 }
2563 // Rebroadcast the "application-foreground"
2567 }
2569 }
2572 // Rebroadcast the "application-background"
2576 }
2578 }
2581 // Rebroadcast the "child-gc-request" so that workers will GC.
2585 }
2588 }
2591 // Rebroadcast the "child-cc-request" so that workers will CC.
2595 }
2598 }
2601 #ifdef DEBUG
2603 #endif
2605 }
2621 }
2626 // Allocation of preallocated processes that are still launching can
2627 // cause this
2629 }
2632 // Preallocated processes are type PREALLOC_REMOTE_TYPE; they may not
2633 // become a File: process, or Privileged About Content Process
2637 // prealloc->anything (but file) or web->web allowed, and no-change
2642 // Initial setting of remote type. Either to 'prealloc' or the actual
2643 // final type (if we didn't use a preallocated process)
2650 }
2651 }
2655 // Must do before SetProcessName
2658 // Update the process name so about:memory's process names are more obvious.
2670 // The profiler can sanitize out the eTLD+1
2671 nsDependentCSubstring etld =
2673 #ifdef NIGHTLY_BUILD
2675 #else
2678 #endif
2680 // The profiler can sanitize out the eTLD+1
2681 nsDependentCSubstring etld =
2685 // The profiler can sanitize out the eTLD+1
2686 nsDependentCSubstring etld =
2690 // else "prealloc" or "web" type -> "Web Content"
2692 }
2694 // Turn off Spectre mitigations in isolated web content processes.
2703 }
2705 // Use the prefix to avoid URIs from Fission isolated processes.
2710 }
2712 // A method to initialize anything we need during the preallocation phase
2716 // SetAcceptLanguages() needs to read localized strings (file access),
2717 // which is slow, so do this in prealloc
2719 }
2721 // Call RemoteTypePrefix() on the result to remove URIs if you want to use this
2722 // for telemetry.
2729 }
2741 // If we have received an already-revoked blobURL, we have to keep it alive
2742 // for a while (see BlobURLProtocolHandler) in order to support pending
2743 // operations such as navigation, download and so on.
2746 }
2747 }
2750 }
2758 }
2765 }
2772 }
2778 }
2795 // Record FOG data before the priority change.
2796 // Ignore the change if it's the first time we set the process priority.
2799 }
2810 // Note: keep this in sync with the JS shell (js/src/shell/js.cpp).
2815 #if defined(MOZ_MEMORY)
2818 }
2819 #endif
2826 }
2830 }
2831 }
2834 }
2843 }
2848 // Make sure aObserver isn't released while we wait for the parent
2852 }
2860 }
2870 }
2872 }
2878 }
2883 }
2886 }
2892 }
2897 }
2900 }
2907 }
2913 }
2915 }
2918 "If the domain policy is not active yet,"
2921 }
2929 }
2948 }
2967 }
2970 }
2975 }
2984 }
2985 }
2987 /* static */
2990 }
2996 // Bug 1755376: If we see "RecvShutdownConfirmedHP entry" often in
2997 // bug IPCError_ShutDownKill we might want to anticipate
2998 // ShutdownPhase::AppShutdownConfirmed to start here.
3001 }
3006 // Signal the ongoing shutdown to AppShutdown, this
3007 // will make abort nested SpinEventLoopUntilOrQuit loops
3018 }
3022 }
3027 // If we receive the shutdown message from within a nested event loop, we want
3028 // to wait for that event loop to finish. Otherwise we could prematurely
3029 // terminate an "unload" or "pagehide" event handler (which might be doing a
3030 // sync XHR, for example).
3034 // Note that we only have to check the recursion count for the current
3035 // cooperative thread. Since the Shutdown message is not labeled with a
3036 // SchedulerGroup, there can be no other cooperative threads doing work while
3037 // we're running.
3039 // We're in a nested event loop. Let's delay for an arbitrary period of
3040 // time (100ms) in the hopes that the event loop will have finished by
3041 // then.
3047 }
3051 #ifdef NIGHTLY_BUILD
3054 #endif
3059 }
3066 }
3076 ProfileAndAdditionalInformation shutdownProfileAndAdditionalInformation =
3093 }
3094 // Send the shutdown profile to the parent process through our own
3095 // message channel, which we know will survive for long enough.
3104 }
3108 }
3110 // Start a timer that will ensure we quickly exit after a reasonable period
3111 // of time. Prevents shutdown hangs after our connection to the parent
3112 // closes or when the parent is too busy to ever kill us.
3119 // Notify the parent that we are done with shutdown. This is sent with high
3120 // priority and will just flag we are done.
3123 // Now tell the parent to actually destroy our channel which will make end
3124 // our process. This is expected to be the last event the parent will
3125 // ever process for this ContentChild.
3130 }
3138 }
3140 PContentPermissionRequestChild*
3147 }
3155 }
3161 }
3168 }
3173 }
3181 }
3183 }
3191 }
3200 }
3207 }
3216 }
3224 }
3233 blobImpl);
3235 }
3240 aURI,
3243 }
3253 }
3262 }
3268 // This object can already been deleted in case DeleteGetFilesRequest has
3269 // been called when the response was sending by the parent.
3272 }
3287 }
3290 }
3292 }
3294 /* static */
3296 GeckoChildID aChildID) {
3297 // If we're communicating with the same process or the UI process then we
3298 // want to crash normally. Otherwise we want to just warn as the other end
3299 // must be the GPU process and it crashing shouldn't be fatal for us.
3306 NS_WARNING(formattedMessage.get());
3307 }
3308 }
3310 PURLClassifierChild* ContentChild::AllocPURLClassifierChild(
3311 nsIPrincipal* aPrincipal, bool* aSuccess) {
3312 *aSuccess = true;
3313 return new URLClassifierChild();
3314 }
3316 bool ContentChild::DeallocPURLClassifierChild(PURLClassifierChild* aActor) {
3317 MOZ_ASSERT(aActor);
3318 delete aActor;
3319 return true;
3320 }
3322 PURLClassifierLocalChild* ContentChild::AllocPURLClassifierLocalChild(
3323 nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures) {
3324 return new URLClassifierLocalChild();
3325 }
3327 bool ContentChild::DeallocPURLClassifierLocalChild(
3328 PURLClassifierLocalChild* aActor) {
3329 MOZ_ASSERT(aActor);
3330 delete aActor;
3331 return true;
3332 }
3334 PSessionStorageObserverChild*
3335 ContentChild::AllocPSessionStorageObserverChild() {
3336 MOZ_CRASH(
3338 }
3340 bool ContentChild::DeallocPSessionStorageObserverChild(
3341 PSessionStorageObserverChild* aActor) {
3342 MOZ_ASSERT(aActor);
3344 delete aActor;
3345 return true;
3346 }
3348 mozilla::ipc::IPCResult ContentChild::RecvProvideAnonymousTemporaryFile(
3349 const uint64_t& aID, const FileDescOrError& aFDOrError) {
3350 mozilla::UniquePtr<AnonymousTemporaryFileCallback> callback;
3351 mPendingAnonymousTemporaryFiles.Remove(aID, &callback);
3352 MOZ_ASSERT(callback);
3354 PRFileDesc* prfile = nullptr;
3355 if (aFDOrError.type() == FileDescOrError::Tnsresult) {
3356 DebugOnly<nsresult> rv = aFDOrError.get_nsresult();
3357 MOZ_ASSERT(NS_FAILED(rv));
3358 } else {
3359 auto rawFD = aFDOrError.get_FileDescriptor().ClonePlatformHandle();
3360 prfile = PR_ImportFile(PROsfd(rawFD.release()));
3361 }
3362 (*callback)(prfile);
3363 return IPC_OK();
3364 }
3366 nsresult ContentChild::AsyncOpenAnonymousTemporaryFile(
3367 const AnonymousTemporaryFileCallback& aCallback) {
3368 MOZ_ASSERT(NS_IsMainThread());
3370 static uint64_t id = 0;
3371 auto newID = id++;
3372 if (!SendRequestAnonymousTemporaryFile(newID)) {
3373 return NS_ERROR_FAILURE;
3374 }
3376 // Remember the association with the callback.
3377 MOZ_ASSERT(!mPendingAnonymousTemporaryFiles.Get(newID));
3378 mPendingAnonymousTemporaryFiles.GetOrInsertNew(newID, aCallback);
3379 return NS_OK;
3380 }
3382 mozilla::ipc::IPCResult ContentChild::RecvSetPermissionsWithKey(
3383 const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms) {
3384 RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
3385 if (permManager) {
3386 permManager->SetPermissionsWithKey(aPermissionKey, aPerms);
3387 }
3389 return IPC_OK();
3390 }
3392 mozilla::ipc::IPCResult ContentChild::RecvRefreshScreens(
3393 nsTArray<ScreenDetails>&& aScreens) {
3394 ScreenManager& screenManager = ScreenManager::GetSingleton();
3395 screenManager.Refresh(std::move(aScreens));
3396 return IPC_OK();
3397 }
3399 mozilla::ipc::IPCResult ContentChild::RecvShareCodeCoverageMutex(
3400 CrossProcessMutexHandle aHandle) {
3401 #ifdef MOZ_CODE_COVERAGE
3402 CodeCoverageHandler::Init(std::move(aHandle));
3403 return IPC_OK();
3404 #else
3406 #endif
3407 }
3409 mozilla::ipc::IPCResult ContentChild::RecvFlushCodeCoverageCounters(
3410 FlushCodeCoverageCountersResolver&& aResolver) {
3411 #ifdef MOZ_CODE_COVERAGE
3412 CodeCoverageHandler::FlushCounters();
3413 aResolver(/* unused */ true);
3414 return IPC_OK();
3415 #else
3417 #endif
3418 }
3420 mozilla::ipc::IPCResult ContentChild::RecvSetInputEventQueueEnabled() {
3421 nsThreadManager::get().EnableMainThreadEventPrioritization();
3422 return IPC_OK();
3423 }
3425 mozilla::ipc::IPCResult ContentChild::RecvFlushInputEventQueue() {
3426 nsThreadManager::get().FlushInputEventPrioritization();
3427 return IPC_OK();
3428 }
3430 mozilla::ipc::IPCResult ContentChild::RecvSuspendInputEventQueue() {
3431 nsThreadManager::get().SuspendInputEventPrioritization();
3432 return IPC_OK();
3433 }
3435 mozilla::ipc::IPCResult ContentChild::RecvResumeInputEventQueue() {
3436 nsThreadManager::get().ResumeInputEventPrioritization();
3437 return IPC_OK();
3438 }
3440 mozilla::ipc::IPCResult ContentChild::RecvAddDynamicScalars(
3441 nsTArray<DynamicScalarDefinition>&& aDefs) {
3442 TelemetryIPC::AddDynamicScalarDefinitions(aDefs);
3443 return IPC_OK();
3444 }
3446 mozilla::ipc::IPCResult ContentChild::RecvCrossProcessRedirect(
3447 RedirectToRealChannelArgs&& aArgs,
3448 nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
3449 CrossProcessRedirectResolver&& aResolve) {
3450 nsCOMPtr<nsILoadInfo> loadInfo;
3451 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
3452 aArgs.loadInfo(), NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
3453 if (NS_FAILED(rv)) {
3455 return IPC_OK();
3456 }
3458 nsCOMPtr<nsIChannel> newChannel;
3459 MOZ_ASSERT((aArgs.loadStateInternalLoadFlags() &
3460 nsDocShell::InternalLoad::INTERNAL_LOAD_FLAGS_IS_SRCDOC) ||
3461 aArgs.srcdocData().IsVoid());
3462 rv = nsDocShell::CreateRealChannelForDocument(
3463 getter_AddRefs(newChannel), aArgs.uri(), loadInfo, nullptr,
3464 aArgs.newLoadFlags(), aArgs.srcdocData(), aArgs.baseUri());
3466 if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
3467 httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
3468 httpChannel->SetEarlyHintLinkType(aArgs.earlyHintLinkType());
3469 }
3471 // This is used to report any errors back to the parent by calling
3472 // CrossProcessRedirectFinished.
3473 RefPtr<HttpChannelChild> httpChild = do_QueryObject(newChannel);
3474 auto resolve = [=](const nsresult& aRv) {
3475 nsresult rv = aRv;
3476 if (httpChild) {
3477 rv = httpChild->CrossProcessRedirectFinished(rv);
3478 }
3479 aResolve(rv);
3480 };
3481 auto scopeExit = MakeScopeExit([&]() { resolve(rv); });
3483 if (NS_FAILED(rv)) {
3484 return IPC_OK();
3485 }
3487 if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel)) {
3488 rv = httpChannel->SetChannelId(aArgs.channelId());
3489 }
3490 if (NS_FAILED(rv)) {
3491 return IPC_OK();
3492 }
3494 rv = newChannel->SetOriginalURI(aArgs.originalURI());
3495 if (NS_FAILED(rv)) {
3496 return IPC_OK();
3497 }
3499 if (nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
3500 do_QueryInterface(newChannel)) {
3501 rv = httpChannelInternal->SetRedirectMode(aArgs.redirectMode());
3502 }
3503 if (NS_FAILED(rv)) {
3504 return IPC_OK();
3505 }
3507 if (aArgs.init()) {
3508 HttpBaseChannel::ReplacementChannelConfig config(std::move(*aArgs.init()));
3509 HttpBaseChannel::ConfigureReplacementChannel(
3510 newChannel, config,
3511 HttpBaseChannel::ReplacementReason::DocumentChannel);
3512 }
3514 if (aArgs.contentDisposition()) {
3515 newChannel->SetContentDisposition(*aArgs.contentDisposition());
3516 }
3518 if (aArgs.contentDispositionFilename()) {
3519 newChannel->SetContentDispositionFilename(
3520 *aArgs.contentDispositionFilename());
3521 }
3523 if (nsCOMPtr<nsIChildChannel> childChannel = do_QueryInterface(newChannel)) {
3524 // Connect to the parent if this is a remote channel. If it's entirely
3525 // handled locally, then we'll call AsyncOpen from the docshell when
3526 // we complete the setup
3527 rv = childChannel->ConnectParent(
3528 aArgs.registrarId()); // creates parent channel
3529 if (NS_FAILED(rv)) {
3530 return IPC_OK();
3531 }
3532 }
3534 // We need to copy the property bag before signaling that the channel
3535 // is ready so that the nsDocShell can retrieve the history data when called.
3536 if (nsCOMPtr<nsIWritablePropertyBag> bag = do_QueryInterface(newChannel)) {
3537 nsHashPropertyBag::CopyFrom(bag, aArgs.properties());
3538 }
3540 RefPtr<nsDocShellLoadState> loadState;
3541 rv = nsDocShellLoadState::CreateFromPendingChannel(
3542 newChannel, aArgs.loadIdentifier(), aArgs.registrarId(),
3543 getter_AddRefs(loadState));
3544 if (NS_WARN_IF(NS_FAILED(rv))) {
3545 return IPC_OK();
3546 }
3547 loadState->SetLoadFlags(aArgs.loadStateExternalLoadFlags());
3548 loadState->SetInternalLoadFlags(aArgs.loadStateInternalLoadFlags());
3549 if (IsValidLoadType(aArgs.loadStateLoadType())) {
3550 loadState->SetLoadType(aArgs.loadStateLoadType());
3551 }
3553 if (aArgs.loadingSessionHistoryInfo().isSome()) {
3554 loadState->SetLoadingSessionHistoryInfo(
3555 aArgs.loadingSessionHistoryInfo().ref());
3556 }
3557 if (aArgs.originalUriString().isSome()) {
3558 loadState->SetOriginalURIString(aArgs.originalUriString().ref());
3559 }
3561 RefPtr<ChildProcessChannelListener> processListener =
3562 ChildProcessChannelListener::GetSingleton();
3563 // The listener will call completeRedirectSetup or asyncOpen on the channel.
3564 processListener->OnChannelReady(loadState, aArgs.loadIdentifier(),
3565 std::move(aEndpoints), aArgs.timing(),
3566 std::move(resolve));
3567 scopeExit.release();
3569 // scopeExit will call CrossProcessRedirectFinished(rv) here
3570 return IPC_OK();
3571 }
3573 mozilla::ipc::IPCResult ContentChild::RecvStartDelayedAutoplayMediaComponents(
3574 const MaybeDiscarded<BrowsingContext>& aContext) {
3575 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3576 return IPC_OK();
3577 }
3579 aContext.get()->StartDelayedAutoplayMediaComponents();
3580 return IPC_OK();
3581 }
3583 mozilla::ipc::IPCResult ContentChild::RecvUpdateMediaControlAction(
3584 const MaybeDiscarded<BrowsingContext>& aContext,
3585 const MediaControlAction& aAction) {
3586 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3587 return IPC_OK();
3588 }
3590 ContentMediaControlKeyHandler::HandleMediaControlAction(aContext.get(),
3591 aAction);
3592 return IPC_OK();
3593 }
3595 mozilla::ipc::IPCResult ContentChild::RecvOnAllowAccessFor(
3596 const MaybeDiscarded<BrowsingContext>& aContext,
3597 const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
3598 const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
3599 aReason) {
3602 StorageAccessAPIHelper::OnAllowAccessFor(
3603 aContext.GetMaybeDiscarded(), aTrackingOrigin, aCookieBehavior, aReason);
3605 return IPC_OK();
3606 }
3608 mozilla::ipc::IPCResult ContentChild::RecvOnContentBlockingDecision(
3609 const MaybeDiscarded<BrowsingContext>& aContext,
3610 const ContentBlockingNotifier::BlockingDecision& aDecision,
3611 uint32_t aRejectedReason) {
3614 nsCOMPtr<nsPIDOMWindowOuter> outer = aContext.get()->GetDOMWindow();
3615 if (!outer) {
3616 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3619 return IPC_OK();
3620 }
3622 nsCOMPtr<nsPIDOMWindowInner> inner = outer->GetCurrentInnerWindow();
3623 if (!inner) {
3624 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3627 return IPC_OK();
3628 }
3630 ContentBlockingNotifier::OnDecision(inner, aDecision, aRejectedReason);
3631 return IPC_OK();
3632 }
3634 #ifdef NIGHTLY_BUILD
3635 void ContentChild::OnChannelReceivedMessage(const Message& aMsg) {
3636 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3637 mPendingInputEvents++;
3638 }
3639 }
3641 PContentChild::Result ContentChild::OnMessageReceived(const Message& aMsg) {
3642 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3643 DebugOnly<uint32_t> prevEvts = mPendingInputEvents--;
3644 MOZ_ASSERT(prevEvts > 0);
3645 }
3647 return PContentChild::OnMessageReceived(aMsg);
3648 }
3650 PContentChild::Result ContentChild::OnMessageReceived(
3651 const Message& aMsg, UniquePtr<Message>& aReply) {
3652 return PContentChild::OnMessageReceived(aMsg, aReply);
3653 }
3654 #endif
3656 mozilla::ipc::IPCResult ContentChild::RecvCreateBrowsingContext(
3657 uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit) {
3658 // We can't already have a BrowsingContext with this ID.
3659 if (RefPtr<BrowsingContext> existing = BrowsingContext::Get(aInit.mId)) {
3661 }
3663 RefPtr<WindowContext> parent = WindowContext::GetById(aInit.mParentId);
3664 if (!parent && aInit.mParentId != 0) {
3665 // Handle this case by ignoring the request, as parent must be in the
3666 // process of being discarded.
3667 // In the future it would be nice to avoid sending this message to the child
3668 // at all.
3670 return IPC_OK();
3671 }
3673 RefPtr<BrowsingContextGroup> group =
3674 BrowsingContextGroup::GetOrCreate(aGroupId);
3675 return BrowsingContext::CreateFromIPC(std::move(aInit), group, nullptr);
3676 }
3678 mozilla::ipc::IPCResult ContentChild::RecvDiscardBrowsingContext(
3679 const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
3680 DiscardBrowsingContextResolver&& aResolve) {
3681 if (BrowsingContext* context = aContext.GetMaybeDiscarded()) {
3682 if (aDoDiscard && !context->IsDiscarded()) {
3683 context->Detach(/* aFromIPC */ true);
3684 }
3685 context->AddDiscardListener(aResolve);
3686 return IPC_OK();
3687 }
3689 // Immediately resolve the promise, as we've received the message. This will
3690 // allow the parent process to discard references to this BC.
3691 aResolve(true);
3692 return IPC_OK();
3693 }
3695 mozilla::ipc::IPCResult ContentChild::RecvRegisterBrowsingContextGroup(
3696 uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits) {
3697 RefPtr<BrowsingContextGroup> group =
3698 BrowsingContextGroup::GetOrCreate(aGroupId);
3700 // Each of the initializers in aInits is sorted in pre-order, so our parent
3701 // should always be available before the element itself.
3702 for (auto& initUnion : aInits) {
3703 switch (initUnion.type()) {
3704 case SyncedContextInitializer::TBrowsingContextInitializer: {
3705 auto& init = initUnion.get_BrowsingContextInitializer();
3706 #ifdef DEBUG
3707 RefPtr<BrowsingContext> existing = BrowsingContext::Get(init.mId);
3710 RefPtr<WindowContext> parent = init.GetParent();
3711 MOZ_ASSERT_IF(parent, parent->Group() == group);
3712 #endif
3714 BrowsingContext::CreateFromIPC(std::move(init), group, nullptr);
3715 break;
3716 }
3717 case SyncedContextInitializer::TWindowContextInitializer: {
3718 auto& init = initUnion.get_WindowContextInitializer();
3719 #ifdef DEBUG
3720 RefPtr<WindowContext> existing =
3721 WindowContext::GetById(init.mInnerWindowId);
3723 RefPtr<BrowsingContext> parent =
3724 BrowsingContext::Get(init.mBrowsingContextId);
3725 MOZ_ASSERT(parent && parent->Group() == group);
3726 #endif
3728 WindowContext::CreateFromIPC(std::move(init));
3729 break;
3730 };
3731 default:
3732 MOZ_ASSERT_UNREACHABLE();
3733 }
3734 }
3736 return IPC_OK();
3737 }
3739 mozilla::ipc::IPCResult ContentChild::RecvDestroyBrowsingContextGroup(
3740 uint64_t aGroupId) {
3741 if (RefPtr<BrowsingContextGroup> group =
3742 BrowsingContextGroup::GetExisting(aGroupId)) {
3743 group->ChildDestroy();
3744 }
3745 return IPC_OK();
3746 }
3748 mozilla::ipc::IPCResult ContentChild::RecvWindowClose(
3749 const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller) {
3750 if (aContext.IsNullOrDiscarded()) {
3751 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3753 return IPC_OK();
3754 }
3756 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3757 if (!window) {
3758 MOZ_LOG(
3759 BrowsingContext::GetLog(), LogLevel::Debug,
3761 return IPC_OK();
3762 }
3764 // Call `GetDocument()` to force the document and its inner window to be
3765 // created, as it would be forced to be created if this call was being
3766 // performed in-process.
3767 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3768 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3771 return IPC_OK();
3772 }
3774 nsGlobalWindowOuter::Cast(window)->CloseOuter(aTrustedCaller);
3775 return IPC_OK();
3776 }
3778 mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(
3779 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3780 uint64_t aActionId) {
3781 if (aContext.IsNullOrDiscarded()) {
3782 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3784 return IPC_OK();
3785 }
3787 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3788 if (!window) {
3789 MOZ_LOG(
3790 BrowsingContext::GetLog(), LogLevel::Debug,
3792 return IPC_OK();
3793 }
3795 // Call `GetDocument()` to force the document and its inner window to be
3796 // created, as it would be forced to be created if this call was being
3797 // performed in-process.
3798 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3799 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3802 return IPC_OK();
3803 }
3805 nsGlobalWindowOuter::Cast(window)->FocusOuter(
3806 aCallerType, /* aFromOtherProcess */ true, aActionId);
3807 return IPC_OK();
3808 }
3810 mozilla::ipc::IPCResult ContentChild::RecvWindowBlur(
3811 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType) {
3812 if (aContext.IsNullOrDiscarded()) {
3813 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3815 return IPC_OK();
3816 }
3818 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3819 if (!window) {
3820 MOZ_LOG(
3821 BrowsingContext::GetLog(), LogLevel::Debug,
3823 return IPC_OK();
3824 }
3826 // Call `GetDocument()` to force the document and its inner window to be
3827 // created, as it would be forced to be created if this call was being
3828 // performed in-process.
3829 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3830 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3833 return IPC_OK();
3834 }
3836 nsGlobalWindowOuter::Cast(window)->BlurOuter(aCallerType);
3837 return IPC_OK();
3838 }
3840 mozilla::ipc::IPCResult ContentChild::RecvRaiseWindow(
3841 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3842 uint64_t aActionId) {
3843 if (aContext.IsNullOrDiscarded()) {
3844 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3846 return IPC_OK();
3847 }
3849 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3850 if (!window) {
3851 MOZ_LOG(
3852 BrowsingContext::GetLog(), LogLevel::Debug,
3854 return IPC_OK();
3855 }
3857 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3858 fm->RaiseWindow(window, aCallerType, aActionId);
3859 }
3860 return IPC_OK();
3861 }
3863 mozilla::ipc::IPCResult ContentChild::RecvAdjustWindowFocus(
3864 const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
3865 uint64_t aActionId, bool aShouldClearAncestorFocus,
3866 const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus) {
3867 if (aContext.IsNullOrDiscarded()) {
3868 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3870 return IPC_OK();
3871 }
3873 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3874 RefPtr<BrowsingContext> bc = aContext.get();
3875 RefPtr<BrowsingContext> ancestor =
3876 aAncestorBrowsingContextToFocus.IsNullOrDiscarded()
3877 ? nullptr
3878 : aAncestorBrowsingContextToFocus.get();
3879 fm->AdjustInProcessWindowFocus(bc, false, aIsVisible, aActionId,
3880 aShouldClearAncestorFocus, ancestor);
3881 }
3882 return IPC_OK();
3883 }
3885 mozilla::ipc::IPCResult ContentChild::RecvClearFocus(
3886 const MaybeDiscarded<BrowsingContext>& aContext) {
3887 if (aContext.IsNullOrDiscarded()) {
3888 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3890 return IPC_OK();
3891 }
3893 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3894 if (!window) {
3895 MOZ_LOG(
3896 BrowsingContext::GetLog(), LogLevel::Debug,
3898 return IPC_OK();
3899 }
3901 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3902 fm->ClearFocus(window);
3903 }
3904 return IPC_OK();
3905 }
3907 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedBrowsingContext(
3908 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3909 if (aContext.IsNullOrDiscarded()) {
3910 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3912 return IPC_OK();
3913 }
3915 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3916 if (fm) {
3917 fm->SetFocusedBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3918 }
3919 return IPC_OK();
3920 }
3922 mozilla::ipc::IPCResult ContentChild::RecvSetActiveBrowsingContext(
3923 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3924 if (aContext.IsNullOrDiscarded()) {
3925 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3927 return IPC_OK();
3928 }
3930 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3931 if (fm) {
3932 fm->SetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3933 }
3934 return IPC_OK();
3935 }
3937 mozilla::ipc::IPCResult ContentChild::RecvAbortOrientationPendingPromises(
3938 const MaybeDiscarded<BrowsingContext>& aContext) {
3939 if (aContext.IsNullOrDiscarded()) {
3940 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3942 return IPC_OK();
3943 }
3945 dom::ScreenOrientation::AbortInProcessOrientationPromises(aContext.get());
3946 return IPC_OK();
3947 }
3949 mozilla::ipc::IPCResult ContentChild::RecvUnsetActiveBrowsingContext(
3950 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3951 if (aContext.IsNullOrDiscarded()) {
3952 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3954 return IPC_OK();
3955 }
3957 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3958 if (fm) {
3959 fm->UnsetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3960 }
3961 return IPC_OK();
3962 }
3964 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedElement(
3965 const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus) {
3966 if (aContext.IsNullOrDiscarded()) {
3967 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3969 return IPC_OK();
3970 }
3972 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3973 if (!window) {
3974 MOZ_LOG(
3975 BrowsingContext::GetLog(), LogLevel::Debug,
3977 return IPC_OK();
3978 }
3980 window->SetFocusedElement(nullptr, 0, aNeedsFocus);
3981 return IPC_OK();
3982 }
3984 mozilla::ipc::IPCResult ContentChild::RecvFinalizeFocusOuter(
3985 const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
3986 CallerType aCallerType) {
3987 if (aContext.IsNullOrDiscarded()) {
3988 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3990 return IPC_OK();
3991 }
3993 if (Element* frame = aContext.get()->GetEmbedderElement()) {
3994 nsContentUtils::RequestFrameFocus(*frame, aCanFocus, aCallerType);
3995 }
3997 return IPC_OK();
3998 }
4000 mozilla::ipc::IPCResult ContentChild::RecvBlurToChild(
4001 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4002 const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
4003 const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
4004 bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId) {
4005 if (aFocusedBrowsingContext.IsNullOrDiscarded()) {
4006 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4008 return IPC_OK();
4009 }
4011 RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
4012 if (MOZ_UNLIKELY(!fm)) {
4013 return IPC_OK();
4014 }
4016 RefPtr<BrowsingContext> toClear = aBrowsingContextToClear.IsDiscarded()
4017 ? nullptr
4018 : aBrowsingContextToClear.get();
4019 RefPtr<BrowsingContext> toFocus =
4020 aAncestorBrowsingContextToFocus.IsDiscarded()
4021 ? nullptr
4022 : aAncestorBrowsingContextToFocus.get();
4024 RefPtr<BrowsingContext> focusedBrowsingContext =
4025 aFocusedBrowsingContext.get();
4027 fm->BlurFromOtherProcess(focusedBrowsingContext, toClear, toFocus,
4028 aIsLeavingDocument, aAdjustWidget, aActionId);
4029 return IPC_OK();
4030 }
4032 mozilla::ipc::IPCResult ContentChild::RecvSetupFocusedAndActive(
4033 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4034 uint64_t aActionIdForFocused,
4035 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4036 uint64_t aActionIdForActive) {
4037 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4038 if (fm) {
4039 if (!aActiveBrowsingContext.IsNullOrDiscarded()) {
4040 fm->SetActiveBrowsingContextFromOtherProcess(aActiveBrowsingContext.get(),
4041 aActionIdForActive);
4042 }
4043 if (!aFocusedBrowsingContext.IsNullOrDiscarded()) {
4044 fm->SetFocusedBrowsingContextFromOtherProcess(
4045 aFocusedBrowsingContext.get(), aActionIdForFocused);
4046 }
4047 }
4048 return IPC_OK();
4049 }
4051 mozilla::ipc::IPCResult ContentChild::RecvReviseActiveBrowsingContext(
4052 uint64_t aOldActionId,
4053 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4054 uint64_t aNewActionId) {
4055 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4056 if (fm && !aActiveBrowsingContext.IsNullOrDiscarded()) {
4057 fm->ReviseActiveBrowsingContext(aOldActionId, aActiveBrowsingContext.get(),
4058 aNewActionId);
4059 }
4060 return IPC_OK();
4061 }
4063 mozilla::ipc::IPCResult ContentChild::RecvReviseFocusedBrowsingContext(
4064 uint64_t aOldActionId,
4065 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4066 uint64_t aNewActionId) {
4067 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4068 if (fm && !aFocusedBrowsingContext.IsNullOrDiscarded()) {
4069 fm->ReviseFocusedBrowsingContext(
4070 aOldActionId, aFocusedBrowsingContext.get(), aNewActionId);
4071 }
4072 return IPC_OK();
4073 }
4075 mozilla::ipc::IPCResult ContentChild::RecvMaybeExitFullscreen(
4076 const MaybeDiscarded<BrowsingContext>& aContext) {
4077 if (aContext.IsNullOrDiscarded()) {
4078 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4080 return IPC_OK();
4081 }
4083 nsIDocShell* shell = aContext.get()->GetDocShell();
4084 if (!shell) {
4085 return IPC_OK();
4086 }
4088 Document* doc = shell->GetDocument();
4089 if (doc && doc->GetFullscreenElement()) {
4090 Document::AsyncExitFullscreen(doc);
4091 }
4093 return IPC_OK();
4094 }
4096 mozilla::ipc::IPCResult ContentChild::RecvWindowPostMessage(
4097 const MaybeDiscarded<BrowsingContext>& aContext,
4098 const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData) {
4099 if (aContext.IsNullOrDiscarded()) {
4100 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4102 return IPC_OK();
4103 }
4105 RefPtr<nsGlobalWindowOuter> window =
4106 nsGlobalWindowOuter::Cast(aContext.get()->GetDOMWindow());
4107 if (!window) {
4108 MOZ_LOG(
4109 BrowsingContext::GetLog(), LogLevel::Debug,
4111 return IPC_OK();
4112 }
4114 nsCOMPtr<nsIPrincipal> providedPrincipal;
4115 if (!window->GetPrincipalForPostMessage(
4116 aData.targetOrigin(), aData.targetOriginURI(),
4117 aData.callerPrincipal(), *aData.subjectPrincipal(),
4118 getter_AddRefs(providedPrincipal))) {
4119 return IPC_OK();
4120 }
4122 // Call `GetDocument()` to force the document and its inner window to be
4123 // created, as it would be forced to be created if this call was being
4124 // performed in-process.
4125 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
4126 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4129 return IPC_OK();
4130 }
4132 // It's OK if `sourceBc` has already been discarded, so long as we can
4133 // continue to wrap it.
4134 RefPtr<BrowsingContext> sourceBc = aData.source().GetMaybeDiscarded();
4136 // Create and asynchronously dispatch a runnable which will handle actual DOM
4137 // event creation and dispatch.
4138 RefPtr<PostMessageEvent> event =
4139 new PostMessageEvent(sourceBc, aData.origin(), window, providedPrincipal,
4140 aData.innerWindowId(), aData.callerURI(),
4141 aData.scriptLocation(), aData.isFromPrivateWindow());
4142 event->UnpackFrom(aMessage);
4144 event->DispatchToTargetThread(IgnoredErrorResult());
4145 return IPC_OK();
4146 }
4148 mozilla::ipc::IPCResult ContentChild::RecvCommitBrowsingContextTransaction(
4149 const MaybeDiscarded<BrowsingContext>& aContext,
4150 BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4151 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4152 }
4154 mozilla::ipc::IPCResult ContentChild::RecvCommitWindowContextTransaction(
4155 const MaybeDiscarded<WindowContext>& aContext,
4156 WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4157 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4158 }
4160 mozilla::ipc::IPCResult ContentChild::RecvCreateWindowContext(
4161 WindowContext::IPCInitializer&& aInit) {
4162 RefPtr<BrowsingContext> bc = BrowsingContext::Get(aInit.mBrowsingContextId);
4163 if (!bc) {
4164 // Handle this case by ignoring the request, as bc must be in the process of
4165 // being discarded.
4166 // In the future it would be nice to avoid sending this message to the child
4167 // at all.
4169 return IPC_OK();
4170 }
4172 WindowContext::CreateFromIPC(std::move(aInit));
4173 return IPC_OK();
4174 }
4176 mozilla::ipc::IPCResult ContentChild::RecvDiscardWindowContext(
4177 uint64_t aContextId, DiscardWindowContextResolver&& aResolve) {
4178 // Resolve immediately to acknowledge call
4179 aResolve(true);
4181 RefPtr<WindowContext> window = WindowContext::GetById(aContextId);
4182 if (NS_WARN_IF(!window) || NS_WARN_IF(window->IsDiscarded())) {
4183 return IPC_OK();
4184 }
4186 window->Discard();
4187 return IPC_OK();
4188 }
4190 mozilla::ipc::IPCResult ContentChild::RecvScriptError(
4191 const nsString& aMessage, const nsCString& aSourceName,
4192 const uint32_t& aLineNumber, const uint32_t& aColNumber,
4193 const uint32_t& aFlags, const nsCString& aCategory,
4194 const bool& aFromPrivateWindow, const uint64_t& aInnerWindowId,
4195 const bool& aFromChromeContext) {
4196 nsresult rv = NS_OK;
4197 nsCOMPtr<nsIConsoleService> consoleService =
4198 do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
4201 nsCOMPtr<nsIScriptError> scriptError(
4202 do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
4203 NS_ENSURE_TRUE(scriptError,
4206 scriptError->InitWithWindowID(aMessage, aSourceName, aLineNumber, aColNumber,
4207 aFlags, aCategory, aInnerWindowId,
4208 aFromChromeContext);
4209 rv = consoleService->LogMessage(scriptError);
4212 return IPC_OK();
4213 }
4215 mozilla::ipc::IPCResult ContentChild::RecvReportFrameTimingData(
4216 const LoadInfoArgs& loadInfoArgs, const nsString& entryName,
4217 const nsString& initiatorType, UniquePtr<PerformanceTimingData>&& aData) {
4218 if (!aData) {
4220 }
4222 nsCOMPtr<nsILoadInfo> loadInfo;
4223 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
4224 loadInfoArgs, NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
4225 if (NS_FAILED(rv)) {
4227 return IPC_OK();
4228 }
4230 // It is important to call LoadInfo::GetPerformanceStorage instead of simply
4231 // getting the performance object via the innerWindowID in order to perform
4232 // necessary cross origin checks.
4233 if (PerformanceStorage* storage = loadInfo->GetPerformanceStorage()) {
4234 storage->AddEntry(entryName, initiatorType, std::move(aData));
4235 }
4236 return IPC_OK();
4237 }
4239 mozilla::ipc::IPCResult ContentChild::RecvLoadURI(
4240 const MaybeDiscarded<BrowsingContext>& aContext,
4241 nsDocShellLoadState* aLoadState, bool aSetNavigating,
4242 LoadURIResolver&& aResolve) {
4243 auto resolveOnExit = MakeScopeExit([&] { aResolve(true); });
4245 if (aContext.IsNullOrDiscarded()) {
4246 return IPC_OK();
4247 }
4248 RefPtr<BrowsingContext> context = aContext.get();
4249 if (!context->IsInProcess()) {
4250 // The DocShell has been torn down or the BrowsingContext has changed
4251 // process in the middle of the load request. There's not much we can do at
4252 // this point, so just give up.
4253 return IPC_OK();
4254 }
4256 context->LoadURI(aLoadState, aSetNavigating);
4258 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4259 BrowserChild* bc = BrowserChild::GetFrom(window);
4260 if (bc) {
4261 bc->NotifyNavigationFinished();
4262 }
4264 #ifdef MOZ_CRASHREPORTER
4265 if (CrashReporter::GetEnabled()) {
4266 nsCOMPtr<nsIURI> annotationURI;
4268 nsresult rv = NS_MutateURI(aLoadState->URI())
4270 .Finalize(annotationURI);
4272 if (NS_FAILED(rv)) {
4273 // Ignore failures on about: URIs.
4274 annotationURI = aLoadState->URI();
4275 }
4277 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4278 annotationURI->GetSpecOrDefault());
4279 }
4280 #endif
4282 return IPC_OK();
4283 }
4285 mozilla::ipc::IPCResult ContentChild::RecvInternalLoad(
4286 nsDocShellLoadState* aLoadState) {
4287 if (!aLoadState->Target().IsEmpty() ||
4288 aLoadState->TargetBrowsingContext().IsNull()) {
4290 }
4291 if (aLoadState->TargetBrowsingContext().IsDiscarded()) {
4292 return IPC_OK();
4293 }
4294 RefPtr<BrowsingContext> context = aLoadState->TargetBrowsingContext().get();
4296 context->InternalLoad(aLoadState);
4298 #ifdef MOZ_CRASHREPORTER
4299 if (CrashReporter::GetEnabled()) {
4300 nsCOMPtr<nsIURI> annotationURI;
4302 nsresult rv = NS_MutateURI(aLoadState->URI())
4304 .Finalize(annotationURI);
4306 if (NS_FAILED(rv)) {
4307 // Ignore failures on about: URIs.
4308 annotationURI = aLoadState->URI();
4309 }
4311 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4312 annotationURI->GetSpecOrDefault());
4313 }
4314 #endif
4316 return IPC_OK();
4317 }
4319 mozilla::ipc::IPCResult ContentChild::RecvDisplayLoadError(
4320 const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI) {
4321 if (aContext.IsNullOrDiscarded()) {
4322 return IPC_OK();
4323 }
4324 RefPtr<BrowsingContext> context = aContext.get();
4326 context->DisplayLoadError(aURI);
4328 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4329 BrowserChild* bc = BrowserChild::GetFrom(window);
4330 if (bc) {
4331 bc->NotifyNavigationFinished();
4332 }
4333 return IPC_OK();
4334 }
4336 mozilla::ipc::IPCResult ContentChild::RecvHistoryCommitIndexAndLength(
4337 const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
4338 const uint32_t& aLength, const nsID& aChangeID) {
4339 if (!aContext.IsNullOrDiscarded()) {
4340 ChildSHistory* shistory = aContext.get()->GetChildSessionHistory();
4341 if (shistory) {
4342 shistory->SetIndexAndLength(aIndex, aLength, aChangeID);
4343 }
4344 }
4345 return IPC_OK();
4346 }
4348 mozilla::ipc::IPCResult ContentChild::RecvGetLayoutHistoryState(
4349 const MaybeDiscarded<BrowsingContext>& aContext,
4350 GetLayoutHistoryStateResolver&& aResolver) {
4351 nsCOMPtr<nsILayoutHistoryState> state;
4352 nsIDocShell* docShell;
4353 mozilla::Maybe<mozilla::dom::Wireframe> wireframe;
4354 if (!aContext.IsNullOrDiscarded() &&
4355 (docShell = aContext.get()->GetDocShell())) {
4356 docShell->PersistLayoutHistoryState();
4357 docShell->GetLayoutHistoryState(getter_AddRefs(state));
4358 wireframe = static_cast<nsDocShell*>(docShell)->GetWireframe();
4359 }
4360 aResolver(
4361 std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&>(
4362 state, wireframe));
4364 return IPC_OK();
4365 }
4367 mozilla::ipc::IPCResult ContentChild::RecvDispatchLocationChangeEvent(
4368 const MaybeDiscarded<BrowsingContext>& aContext) {
4369 if (!aContext.IsNullOrDiscarded() && aContext.get()->GetDocShell()) {
4370 aContext.get()->GetDocShell()->DispatchLocationChangeEvent();
4371 }
4372 return IPC_OK();
4373 }
4375 mozilla::ipc::IPCResult ContentChild::RecvDispatchBeforeUnloadToSubtree(
4376 const MaybeDiscarded<BrowsingContext>& aStartingAt,
4377 DispatchBeforeUnloadToSubtreeResolver&& aResolver) {
4378 if (aStartingAt.IsNullOrDiscarded()) {
4379 aResolver(nsIDocumentViewer::eAllowNavigation);
4380 } else {
4381 DispatchBeforeUnloadToSubtree(aStartingAt.get(), std::move(aResolver));
4382 }
4383 return IPC_OK();
4384 }
4386 mozilla::ipc::IPCResult ContentChild::RecvInitNextGenLocalStorageEnabled(
4387 const bool& aEnabled) {
4388 mozilla::dom::RecvInitNextGenLocalStorageEnabled(aEnabled);
4390 return IPC_OK();
4391 }
4393 /* static */ void ContentChild::DispatchBeforeUnloadToSubtree(
4394 BrowsingContext* aStartingAt,
4395 const DispatchBeforeUnloadToSubtreeResolver& aResolver) {
4396 bool resolved = false;
4398 aStartingAt->PreOrderWalk([&](dom::BrowsingContext* aBC) {
4399 if (aBC->GetDocShell()) {
4400 nsCOMPtr<nsIDocumentViewer> viewer;
4401 aBC->GetDocShell()->GetDocViewer(getter_AddRefs(viewer));
4402 if (viewer &&
4403 viewer->DispatchBeforeUnload() ==
4404 nsIDocumentViewer::eRequestBlockNavigation &&
4405 !resolved) {
4406 // Send our response as soon as we find any blocker, so that we can show
4407 // the permit unload prompt as soon as possible, without giving
4408 // subsequent handlers a chance to delay it.
4409 aResolver(nsIDocumentViewer::eRequestBlockNavigation);
4410 resolved = true;
4411 }
4412 }
4413 });
4415 if (!resolved) {
4416 aResolver(nsIDocumentViewer::eAllowNavigation);
4417 }
4418 }
4420 mozilla::ipc::IPCResult ContentChild::RecvGoBack(
4421 const MaybeDiscarded<BrowsingContext>& aContext,
4422 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4423 bool aUserActivation) {
4424 if (aContext.IsNullOrDiscarded()) {
4425 return IPC_OK();
4426 }
4427 BrowsingContext* bc = aContext.get();
4429 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4430 if (aCancelContentJSEpoch) {
4431 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4432 }
4433 docShell->GoBack(aRequireUserInteraction, aUserActivation);
4435 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4436 browserChild->NotifyNavigationFinished();
4437 }
4438 }
4440 return IPC_OK();
4441 }
4443 mozilla::ipc::IPCResult ContentChild::RecvGoForward(
4444 const MaybeDiscarded<BrowsingContext>& aContext,
4445 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4446 bool aUserActivation) {
4447 if (aContext.IsNullOrDiscarded()) {
4448 return IPC_OK();
4449 }
4450 BrowsingContext* bc = aContext.get();
4452 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4453 if (aCancelContentJSEpoch) {
4454 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4455 }
4456 docShell->GoForward(aRequireUserInteraction, aUserActivation);
4458 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4459 browserChild->NotifyNavigationFinished();
4460 }
4461 }
4463 return IPC_OK();
4464 }
4466 mozilla::ipc::IPCResult ContentChild::RecvGoToIndex(
4467 const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
4468 const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation) {
4469 if (aContext.IsNullOrDiscarded()) {
4470 return IPC_OK();
4471 }
4472 BrowsingContext* bc = aContext.get();
4474 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4475 if (aCancelContentJSEpoch) {
4476 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4477 }
4478 docShell->GotoIndex(aIndex, aUserActivation);
4480 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4481 browserChild->NotifyNavigationFinished();
4482 }
4483 }
4485 return IPC_OK();
4486 }
4488 mozilla::ipc::IPCResult ContentChild::RecvReload(
4489 const MaybeDiscarded<BrowsingContext>& aContext,
4490 const uint32_t aReloadFlags) {
4491 if (aContext.IsNullOrDiscarded()) {
4492 return IPC_OK();
4493 }
4494 BrowsingContext* bc = aContext.get();
4496 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4497 docShell->Reload(aReloadFlags);
4498 }
4500 return IPC_OK();
4501 }
4503 mozilla::ipc::IPCResult ContentChild::RecvStopLoad(
4504 const MaybeDiscarded<BrowsingContext>& aContext,
4505 const uint32_t aStopFlags) {
4506 if (aContext.IsNullOrDiscarded()) {
4507 return IPC_OK();
4508 }
4509 BrowsingContext* bc = aContext.get();
4511 if (auto* docShell = nsDocShell::Cast(bc->GetDocShell())) {
4512 docShell->Stop(aStopFlags);
4513 }
4515 return IPC_OK();
4516 }
4518 #if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
4519 mozilla::ipc::IPCResult ContentChild::RecvInitSandboxTesting(
4520 Endpoint<PSandboxTestingChild>&& aEndpoint) {
4521 if (!SandboxTestingChild::Initialize(std::move(aEndpoint))) {
4522 return IPC_FAIL(
4524 }
4525 return IPC_OK();
4526 }
4527 #endif
4529 NS_IMETHODIMP ContentChild::GetChildID(uint64_t* aOut) {
4530 *aOut = XRE_GetChildID();
4531 return NS_OK;
4532 }
4534 NS_IMETHODIMP ContentChild::GetActor(const nsACString& aName, JSContext* aCx,
4535 JSProcessActorChild** retval) {
4536 ErrorResult error;
4537 RefPtr<JSProcessActorChild> actor =
4538 JSActorManager::GetActor(aCx, aName, error)
4539 .downcast<JSProcessActorChild>();
4540 if (error.MaybeSetPendingException(aCx)) {
4541 return NS_ERROR_FAILURE;
4542 }
4543 actor.forget(retval);
4544 return NS_OK;
4545 }
4547 NS_IMETHODIMP ContentChild::GetExistingActor(const nsACString& aName,
4548 JSProcessActorChild** retval) {
4549 RefPtr<JSProcessActorChild> actor =
4550 JSActorManager::GetExistingActor(aName).downcast<JSProcessActorChild>();
4551 actor.forget(retval);
4552 return NS_OK;
4553 }
4555 already_AddRefed<JSActor> ContentChild::InitJSActor(
4556 JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
4557 ErrorResult& aRv) {
4558 RefPtr<JSProcessActorChild> actor;
4559 if (aMaybeActor.get()) {
4560 aRv = UNWRAP_OBJECT(JSProcessActorChild, aMaybeActor.get(), actor);
4561 if (aRv.Failed()) {
4562 return nullptr;
4563 }
4564 } else {
4565 actor = new JSProcessActorChild();
4566 }
4568 MOZ_RELEASE_ASSERT(!actor->Manager(),
4570 actor->Init(aName, this);
4571 return actor.forget();
4572 }
4574 IPCResult ContentChild::RecvRawMessage(const JSActorMessageMeta& aMeta,
4575 const Maybe<ClonedMessageData>& aData,
4576 const Maybe<ClonedMessageData>& aStack) {
4577 Maybe<StructuredCloneData> data;
4578 if (aData) {
4579 data.emplace();
4580 data->BorrowFromClonedMessageData(*aData);
4581 }
4582 Maybe<StructuredCloneData> stack;
4583 if (aStack) {
4584 stack.emplace();
4585 stack->BorrowFromClonedMessageData(*aStack);
4586 }
4587 ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
4588 return IPC_OK();
4589 }
4591 NS_IMETHODIMP ContentChild::GetCanSend(bool* aCanSend) {
4592 *aCanSend = CanSend();
4593 return NS_OK;
4594 }
4596 ContentChild* ContentChild::AsContentChild() { return this; }
4598 JSActorManager* ContentChild::AsJSActorManager() { return this; }
4600 IPCResult ContentChild::RecvFlushFOGData(FlushFOGDataResolver&& aResolver) {
4601 glean::FlushFOGData(std::move(aResolver));
4602 return IPC_OK();
4603 }
4605 IPCResult ContentChild::RecvUpdateMediaCodecsSupported(
4606 RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
4607 RemoteDecoderManagerChild::SetSupported(aLocation, aSupported);
4609 return IPC_OK();
4610 }
4612 void ContentChild::ConfigureThreadPerformanceHints(
4613 const hal::ProcessPriority& aPriority) {
4614 if (aPriority >= hal::PROCESS_PRIORITY_FOREGROUND) {
4615 static bool canUsePerformanceHintSession = true;
4616 if (!mPerformanceHintSession && canUsePerformanceHintSession) {
4617 nsTArray<PlatformThreadHandle> threads;
4618 Servo_ThreadPool_GetThreadHandles(&threads);
4619 #ifdef XP_WIN
4620 threads.AppendElement(GetCurrentThread());
4621 #else
4622 threads.AppendElement(pthread_self());
4623 #endif
4625 mPerformanceHintSession = hal::CreatePerformanceHintSession(
4626 threads, GetPerformanceHintTarget(TimeDuration::FromMilliseconds(
4627 nsRefreshDriver::DefaultInterval())));
4629 // Avoid repeatedly attempting to create a session if it is not
4630 // supported.
4631 canUsePerformanceHintSession = mPerformanceHintSession != nullptr;
4632 }
4634 #ifdef MOZ_WIDGET_ANDROID
4635 // On Android if we are unable to use PerformanceHintManager then fall back
4636 // to setting the stylo threads' affinities to the performant cores. Android
4637 // automatically sets each thread's affinity to all cores when a process is
4638 // foregrounded, and to a subset of cores when the process is backgrounded.
4639 // We must therefore override this each time the process is foregrounded,
4640 // but we don't have to do anything when backgrounded.
4641 if (!mPerformanceHintSession) {
4642 if (const auto& cpuInfo = hal::GetHeterogeneousCpuInfo()) {
4643 // If CPUs are homogeneous there is no point setting affinity.
4644 if (cpuInfo->mBigCpus.Count() != cpuInfo->mTotalNumCpus) {
4645 BitSet<hal::HeterogeneousCpuInfo::MAX_CPUS> cpus = cpuInfo->mBigCpus;
4646 if (cpus.Count() < 2) {
4647 // From testing on a variety of devices it appears using only the
4648 // big cores gives best performance when there are 2 or more big
4649 // cores. If there are fewer than 2 big cores then additionally
4650 // using the medium cores performs better.
4651 cpus |= cpuInfo->mMediumCpus;
4652 }
4654 static_assert(
4655 hal::HeterogeneousCpuInfo::MAX_CPUS <= CPU_SETSIZE,
4658 cpu_set_t cpuset;
4659 CPU_ZERO(&cpuset);
4660 for (size_t i = 0; i < cpuInfo->mTotalNumCpus; i++) {
4661 if (cpus.Test(i)) {
4662 CPU_SET(i, &cpuset);
4663 }
4664 }
4666 // Only set the affinity for the stylo threads, not the main thread.
4667 // Testing showed no difference in performance between the two
4668 // options, and as newly spawned threads automatically inherit their
4669 // parent's affinity mask there may be unintended consequences to
4670 // setting the main thread affinity.
4671 nsTArray<PlatformThreadHandle> threads;
4672 Servo_ThreadPool_GetThreadHandles(&threads);
4673 for (pthread_t thread : threads) {
4674 int ret = sched_setaffinity(pthread_gettid_np(thread),
4675 sizeof(cpu_set_t), &cpuset);
4676 // Occasionally sched_setaffinity fails, presumably due to a race
4677 // between us receiving the process foreground signal and whatever
4678 // is responsible for restricting which processes can use certain
4679 // cores. Trying again in a runnable seems to do the trick, but if
4680 // that still fails it's not the end of the world.
4681 if (ret < 0) {
4682 NS_DispatchToCurrentThread(NS_NewRunnableFunction(
4684 [threads = std::move(threads), cpuset] {
4685 for (pthread_t thread : threads) {
4686 sched_setaffinity(pthread_gettid_np(thread),
4687 sizeof(cpu_set_t), &cpuset);
4688 }
4689 }));
4690 break;
4691 }
4692 }
4693 }
4694 }
4695 }
4696 #endif
4697 } else {
4698 mPerformanceHintSession = nullptr;
4699 }
4700 }
4702 } // namespace dom
4704 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
4708 NS_IMETHODIMP
4709 OpenBSDFindPledgeUnveilFilePath(const char* file, nsACString& result) {
4710 struct stat st;
4712 // Allow overriding files in /etc/$MOZ_APP_NAME
4714 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4715 return NS_OK;
4716 }
4718 // Or look in the system default directory
4719 result.Assign(nsPrintfCString(
4721 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4722 return NS_OK;
4723 }
4726 }
4728 NS_IMETHODIMP
4729 OpenBSDPledgePromises(const nsACString& aPath) {
4730 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4731 // a lot of setup before they are supported and we want to pledge early on
4732 // before all of that, so read the file directly
4733 std::ifstream input(PromiseFlatCString(aPath).get());
4735 // Build up one line of pledge promises without comments
4736 nsAutoCString promises;
4737 bool disabled = false;
4738 int linenum = 0;
4739 for (std::string tLine; std::getline(input, tLine);) {
4740 nsAutoCString line(tLine.c_str());
4741 linenum++;
4743 // Cut off any comments at the end of the line, also catches lines
4744 // that are entirely a comment
4746 if (hash >= 0) {
4747 line = Substring(line, 0, hash);
4748 }
4749 line.CompressWhitespace(true, true);
4750 if (line.IsEmpty()) {
4751 continue;
4752 }
4754 if (linenum == 1 && line.EqualsLiteral("disable")) {
4755 disabled = true;
4756 break;
4757 }
4759 if (!promises.IsEmpty()) {
4760 promises.Append(" ");
4761 }
4762 promises.Append(line);
4763 }
4764 input.close();
4766 if (disabled) {
4767 warnx("%s: disabled", PromiseFlatCString(aPath).get());
4768 } else {
4769 MOZ_LOG(
4770 sPledgeLog, LogLevel::Debug,
4772 if (pledge(promises.get(), nullptr) != 0) {
4773 err(1, "%s: pledge(%s) failed", PromiseFlatCString(aPath).get(),
4774 promises.get());
4775 }
4776 }
4778 return NS_OK;
4779 }
4781 void ExpandUnveilPath(nsAutoCString& path) {
4782 // Expand $XDG_RUNTIME_DIR to the environment variable, or ~/.cache
4783 nsCString xdgRuntimeDir(PR_GetEnv("XDG_RUNTIME_DIR"));
4784 if (xdgRuntimeDir.IsEmpty()) {
4785 xdgRuntimeDir = "~/.cache";
4786 }
4787 path.ReplaceSubstring("$XDG_RUNTIME_DIR", xdgRuntimeDir.get());
4789 // Expand $XDG_CONFIG_HOME to the environment variable, or ~/.config
4790 nsCString xdgConfigHome(PR_GetEnv("XDG_CONFIG_HOME"));
4791 if (xdgConfigHome.IsEmpty()) {
4792 xdgConfigHome = "~/.config";
4793 }
4794 path.ReplaceSubstring("$XDG_CONFIG_HOME", xdgConfigHome.get());
4796 // Expand $XDG_CACHE_HOME to the environment variable, or ~/.cache
4797 nsCString xdgCacheHome(PR_GetEnv("XDG_CACHE_HOME"));
4798 if (xdgCacheHome.IsEmpty()) {
4799 xdgCacheHome = "~/.cache";
4800 }
4801 path.ReplaceSubstring("$XDG_CACHE_HOME", xdgCacheHome.get());
4803 // Expand $XDG_DATA_HOME to the environment variable, or ~/.local/share
4804 nsCString xdgDataHome(PR_GetEnv("XDG_DATA_HOME"));
4805 if (xdgDataHome.IsEmpty()) {
4806 xdgDataHome = "~/.local/share";
4807 }
4808 path.ReplaceSubstring("$XDG_DATA_HOME", xdgDataHome.get());
4812 nsresult rv =
4816 }
4821 }
4822 }
4825 // nsLocalFile::CreateAllAncestors would be nice to use
4833 }
4842 }
4843 }
4844 }
4845 }
4847 NS_IMETHODIMP
4849 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4850 // a lot of setup before they are allowed/supported and we want to pledge and
4851 // unveil early on before all of that is setup
4858 linenum++;
4860 // Cut off any comments at the end of the line, also catches lines
4861 // that are entirely a comment
4865 }
4869 }
4874 }
4879 linenum);
4880 }
4893 }
4894 }
4902 // Only unveil the pledgePath file if it's not already unveiled, otherwise
4903 // some containing directory will lose visibility.
4908 }
4911 }
4912 }
4913 }
4916 }
4919 nsAutoCString pledgeFile;
4920 nsAutoCString unveilFile;
4928 // Ensure dconf dir exists before we veil the filesystem
4933 }
4964 }
4970 }
4975 }
4979 }
4983 }
4985 // Don't overwrite an existing session dbus address, but ensure it is set
4988 }
4991 }
4992 #endif
4996 /* static */
5000 }
5002 }