| blob | c445649d70933666b96a5f419379269271629ca8 |
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
110 #ifdef NS_PRINTING
112 #endif
142 #if defined(MOZ_SANDBOX)
144 # if defined(XP_WIN)
147 # elif defined(XP_LINUX)
152 # elif defined(XP_MACOSX)
153 # include <CoreGraphics/CGError.h>
155 # elif defined(__OpenBSD__)
156 # include <err.h>
157 # include <sys/stat.h>
158 # include <unistd.h>
160 # include <fstream>
166 # endif
167 # if defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
169 # endif
170 #endif
218 #ifdef MOZ_WEBRTC
220 #endif
226 #if defined(MOZ_WIDGET_ANDROID)
228 # include <sched.h>
229 #endif
231 #ifdef XP_WIN
232 # include <process.h>
233 # define getpid _getpid
235 #endif
237 #if defined(XP_MACOSX)
239 # include <sys/qos.h>
242 #ifdef MOZ_X11
244 #endif
246 #ifdef ACCESSIBILITY
248 # ifdef XP_WIN
250 # endif
254 #endif
259 #ifdef MOZ_WEBSPEECH
261 #endif
284 #ifdef MOZ_WIDGET_GTK
287 # include <gtk/gtk.h>
288 #endif
290 #ifdef MOZ_CODE_COVERAGE
292 #endif
314 }
320 }
327 "This is a notification of the priority change "
332 }
333 };
338 }
346 }
354 }
355 };
361 // IPC sender for remote GC/CC logging.
367 NS_DECL_ISUPPORTS
374 }
379 }
383 }
391 }
399 }
403 }
407 }
411 }
415 }
419 }
423 }
430 }
434 }
435 // The XPCOM refcount drives the IPC lifecycle;
437 }
441 "This object is a remote GC/CC logger;"
444 }
449 };
453 };
465 nsString mData;
466 };
472 NS_DECL_ISUPPORTS
473 NS_DECL_NSICONSOLELISTENER
480 };
484 // Before we send the error to the parent process (which
485 // involves copying the memory), truncate any long lines. CSS
486 // errors in particular share the memory for long lines with
487 // repeated errors, but the IPC communication we're about to do
488 // will break that sharing, so we better truncate now.
492 }
493 }
495 NS_IMETHODIMP
499 }
504 nsCString category;
531 {
532 AutoJSAPI jsapi;
541 // Because |stack| might be a cross-compartment wrapper, we can't use it
542 // with JSAutoRealm. Use the stackGlobal for that.
549 StructuredCloneData data;
550 ErrorResult err;
554 }
556 ClonedMessageData cloned;
559 }
565 }
566 }
571 }
573 nsString msg;
578 }
580 #ifdef NIGHTLY_BUILD
581 /**
582 * The singleton of this class is registered with the BackgroundHangMonitor as
583 * an annotator, so that the hang monitor can record whether or not there were
584 * pending input events when the thread hung.
585 */
592 }
593 }
596 };
598 #endif
610 // This process is a content process, so it's clearly running in
611 // multiprocess mode!
614 // Our static analysis doesn't allow capturing ref-counted pointers in
615 // lambdas, so we need to hide it in a uintptr_t. This is safe because this
616 // lambda will be destroyed in ~ContentChild().
627 aProfilingState);
628 },
629 self);
631 // When ContentChild is created, the observer service does not even exist.
632 // When ContentChild::RecvSetXPCOMProcessAttributes is called (the first
633 // IPDL call made on this object), shutdown may have already happened. Thus
634 // we create a canary here that relies upon getting cleared if shutdown
635 // happens without requiring the observer service at this time.
639 }
640 }
642 #ifdef _MSC_VER
643 # pragma warning(push)
644 # pragma warning( \
646 */
647 #endif
652 #ifndef NS_FREE_PERMANENT_DATA
654 #endif
655 }
657 #ifdef _MSC_VER
658 # pragma warning(pop)
659 #endif
664 NS_INTERFACE_MAP_END
675 }
685 aIsReadyForBackgroundProcessing);
693 }
695 }
704 }
705 };
710 #ifdef MOZ_WIDGET_GTK
711 // When running X11 only build we need to pass a display down
712 // to gtk_init because it's not going to use the one from the environment
713 // on its own when deciding which backend to use, and when starting under
714 // XWayland, it may choose to start with the wayland backend
715 // instead of the x11 backend.
716 // The DISPLAY environment variable is normally set by the parent process.
717 // The MOZ_GDK_DISPLAY environment variable is set from nsAppRunner.cpp
718 // when --display is set by the command line.
723 # ifdef MOZ_WAYLAND
725 # endif
728 }
729 }
734 // argv0 is unused because g_set_prgname() was called in
735 // XRE_InitChildProcess().
741 }
742 }
743 #endif
745 #ifdef MOZ_X11
747 // Do this after initializing GDK, or GDK will install its own handler.
749 }
750 #endif
754 // Once we start sending IPC messages, we need the thread manager to be
755 // initialized so we can deal with the responses. Do that here before we
756 // try to construct the crash reporter.
760 }
764 }
767 // If communications with the parent have broken down, take the process
768 // down so it's not hanging around.
771 // This must be checked before any IPDL message, which may hit sentinel
772 // errors due to parent and content processes having different
773 // versions.
776 // We need to quit this process if the buildID doesn't match the parent's.
777 // This can occur when an update occurred in the background.
779 }
781 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
783 #endif
785 #ifdef MOZ_X11
786 # ifdef MOZ_WIDGET_GTK
788 // Send the parent our X socket to act as a proxy reference for our X
789 // resources.
792 }
793 # endif
794 #endif
803 #ifdef NIGHTLY_BUILD
804 // NOTE: We have to register the annotator on the main thread, as annotators
805 // only affect a single thread.
810 }));
811 #endif
812 }
820 }
821 }
824 }
831 #ifdef XP_UNIX
835 #elif defined(XP_WIN)
836 // Windows has a decent JIT debugging story, so NS_DebugBreak does the
837 // right thing.
841 #endif
842 }
848 }
852 // Requires pref flip
857 // DEFAULT_PRIVATE_BROWSING_ID is the value when it's not private
863 #ifdef NIGHTLY_BUILD
864 // Nightly can show site names for private windows, with a second pref
866 #endif
867 ) {
868 #if !defined(XP_MACOSX)
869 // Mac doesn't have the 15-character limit Linux does
870 // Sets profiler process name
872 nsAutoCString schemeless;
874 nsAutoCString originSuffix;
879 #endif
880 {
882 }
883 }
884 }
885 }
890 }
892 // else private window, don't change process name, or the pref isn't set
893 // mProcessName is always flat (mProcessName == aName)
900 }
911 }
916 }
921 }
924 }
934 }
939 }
947 }
953 }
957 }
961 }
976 nsresult rv;
981 // Block the attempt to open a new window if the opening BrowsingContext is
982 // not marked to use remote tabs. This ensures that the newly opened window is
983 // correctly remote.
986 }
995 }
997 // Certain conditions complicate the process of creating the new
998 // BrowsingContext, and prevent us from using the
999 // "CreateWindowInDifferentProcess" codepath.
1000 // * With Fission enabled, process selection will happen during the load, so
1001 // switching processes eagerly will not provide a benefit.
1002 // * Windows created for printing must be created within the current process
1003 // so that a static clone of the source document can be created.
1004 // * Sandboxed popups require the full window creation codepath.
1005 // * Loads with form or POST data require the full window creation codepath.
1009 SANDBOX_PROPAGATES_TO_AUXILIARY_BROWSING_CONTEXTS) ||
1013 // If we're in a content process and we have noopener set, there's no reason
1014 // to load in our process, so let's load it elsewhere!
1027 }
1031 }
1038 }
1041 }
1043 }();
1048 }
1051 }
1060 textDirectiveUserActivation);
1062 // We return NS_ERROR_ABORT, so that the caller knows that we've abandoned
1063 // the window open as far as it is concerned.
1065 }
1066 }
1070 // We need to assign a TabGroup to the PBrowser actor before we send it to the
1071 // parent. Otherwise, the parent could send messages to us before we have a
1072 // proper TabGroup for that actor.
1076 }
1090 });
1094 // The initial about:blank document we generate within the nsDocShell will
1095 // almost certainly be replaced at some point. Unfortunately, getting the
1096 // principal right here causes bugs due to frame scripts not getting events
1097 // they expect, due to the real initial about:blank not being created yet.
1098 //
1099 // For this reason, we intentionally mispredict the initial principal here, so
1100 // that we can act the same as we did before when not predicting a result
1101 // principal. This `PWindowGlobal` will almost immediately be destroyed.
1111 }
1119 }
1121 // Open a remote endpoint for our PBrowser actor.
1125 }
1127 // Open a remote endpoint for our PWindowGlobal actor.
1132 }
1134 // Tell the parent process to set up its PBrowserParent.
1140 }
1146 }
1147 });
1149 // Now that |newChild| has had its IPC link established, call |Init| to set it
1150 // up.
1151 // XXX: This MOZ_KnownLive is only necessary because the static analysis can't
1152 // tell that NotNull<RefPtr<BrowserChild>> is a strong pointer.
1157 }
1159 // Set to true when we're ready to return from this function.
1162 // NOTE: Capturing by reference here is safe, as this function won't return
1163 // until one of these callbacks is called.
1172 // Once this function exits, we should try to exit the nested event loop.
1175 // NOTE: We have to handle this immediately in the resolve callback in order
1176 // to make sure that we don't process any more IPC messages before returning
1177 // from ProvideWindowCommon.
1179 // Handle the error which we got back from the parent process, if we got
1180 // one.
1183 }
1188 }
1190 // If the BrowserChild has been torn down, we don't need to do this anymore.
1194 }
1212 }
1214 // Unfortunately we don't get a window unless we've shown the frame. That's
1215 // pretty bogus; see bug 763602.
1225 }
1226 }
1234 }
1235 }
1238 };
1240 // NOTE: Capturing by reference here is safe, as this function won't return
1241 // until one of these callbacks is called.
1247 };
1249 // Send down the request to open the window.
1259 }
1272 // =======================
1273 // Begin Nested Event Loop
1274 // =======================
1276 // We have to wait for a response from SendCreateWindow or with information
1277 // we're going to need to return from this function, So we spin a nested event
1278 // loop until they get back to us.
1280 {
1281 // Suppress event handling for all contexts in our BrowsingContextGroup so
1282 // that event handlers cannot target our new window while it's still being
1283 // opened. Note that pending events that were suppressed while our blocker
1284 // was active will be dispatched asynchronously from a runnable dispatched
1285 // to the main event loop after this function returns, not immediately when
1286 // we leave this scope.
1289 AutoNoJSAPI nojsapi;
1291 // Spin the event loop until we get a response. Callers of this function
1292 // already have to guard against an inner event loop spinning in the
1293 // non-e10s case because of the need to spin one to create a new chrome
1294 // window.
1298 "We are on the main thread, so we should not exit this "
1300 }
1302 // =====================
1303 // End Nested Event Loop
1304 // =====================
1306 // It's possible for our new BrowsingContext to become discarded during the
1307 // nested event loop, in which case we shouldn't return it, since our callers
1308 // will generally not be prepared to deal with that.
1312 }
1314 // We should have the results already set by the callbacks.
1317 }
1325 }
1327 /* static */
1331 }
1334 }
1338 }
1346 }
1348 // Map the shared memory storing the user agent style sheets. Do this as
1349 // early as possible to maximize the chance of being able to map at the
1350 // address we want.
1352 }
1358 #ifdef MOZ_WIDGET_GTK
1359 // LookAndFeel::NativeInit takes a long time to run on Linux, here we schedule
1360 // it as soon as possible after BackgroundChild::Startup to give
1361 // it chance to run ahead of ConstructBrowser
1364 #endif
1366 #if defined(XP_WIN)
1367 // DLL services untrusted modules processing depends on
1368 // BackgroundChild::Startup having been called
1377 }
1381 // RemoteWorkerService will be initialized in RecvRemoteType, to avoid to
1382 // register it to the RemoteWorkerManager while it is still a prealloc
1383 // remoteType and defer it to the point the child process is assigned a.
1384 // actual remoteType.
1390 }
1418 }
1420 }
1427 }
1429 {
1430 AutoJSAPI jsapi;
1433 }
1434 ErrorResult rv;
1441 }
1444 }
1446 // The stylesheet cache is not ready yet. Store this URL for future use.
1452 // Initialize the RemoteDecoderManager thread and its associated PBackground
1453 // channel.
1457 kFissionEnforceBlockList);
1459 kFissionOmitBlockListValues);
1461 // Set the dynamic scalar definitions for this process.
1463 }
1470 nsCString process;
1475 }
1483 },
1484 aResolver);
1486 }
1488 #if defined(XP_WIN)
1496 },
1499 }
1505 }
1507 }
1514 }
1519 // The sink's destructor is called when the last reference goes away, which
1520 // will cause the actor to be closed down.
1525 // Invoke the dumper, which will take a reference to the sink.
1530 }
1537 }
1543 }
1545 }
1551 }
1553 }
1559 }
1565 }
1571 }
1576 // If we are talking to ourselves, or the UI process, then that is a fatal
1577 // protocol error.
1579 }
1581 // If we are talking to the GPU process, then we should recover from this on
1582 // the next ContentChild::RecvReinitRendering call.
1585 }
1587 #if defined(XP_MACOSX)
1590 };
1591 #endif
1601 // Note that for all of the methods below, if it can fail, it should only
1602 // return false if the failure is an IPDL error. In such situations,
1603 // ContentChild can reason about whether or not to wait for
1604 // RecvReinitRendering (because we surmised the GPU process crashed), or if it
1605 // should crash itself (because we are actually talking to the UI process). If
1606 // there are localized failures (e.g. failed to spawn a thread), then it
1607 // should MOZ_RELEASE_ASSERT or MOZ_CRASH as necessary instead.
1610 }
1613 }
1617 }
1620 }
1623 #if defined(XP_MACOSX) && !defined(MOZ_SANDBOX)
1624 // Close all current connections to the WindowServer. This ensures that the
1625 // Activity Monitor will not label the content process as "Not responding"
1626 // because it's not running a native event loop. See bug 1384336. When the
1627 // build is configured with sandbox support, this is called during sandbox
1628 // setup.
1630 #endif
1633 }
1644 // Re-establish singleton bridges to the compositor.
1647 }
1650 }
1654 }
1657 }
1660 // Establish new PLayerTransactions.
1664 }
1665 }
1667 // Notify any observers that the compositor has been reinitialized,
1668 // eg the ZoomConstraintsClients for documents in this process.
1669 // This must occur after the ReinitRendering call above so that the
1670 // APZCTreeManagers have been connected.
1675 }
1679 }
1688 }
1689 }
1691 }
1693 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
1696 };
1699 // Close all current connections to the WindowServer. This ensures that the
1700 // Activity Monitor will not label the content process as "Not responding"
1701 // because it's not running a native event loop. See bug 1384336.
1702 // This is required with or without the sandbox enabled. Until the
1703 // window server is blocked as the policy level, this should be called
1704 // just before CGSSetDenyWindowServerConnections() so there are no
1705 // windowserver connections active when CGSSetDenyWindowServerConnections()
1706 // is called.
1709 // Actual security benefits are only achieved when we additionally deny
1710 // future connections using the sandbox policy. WebGL must be remoted if
1711 // the windowserver connections are blocked. WebGL remoting is disabled
1712 // for some tests.
1719 # if !MOZ_DIAGNOSTIC_ASSERT_ENABLED
1721 # endif
1722 }
1723 }
1724 #endif
1728 // We may want to move the sandbox initialization somewhere else
1729 // at some point; see bug 880808.
1730 #if defined(MOZ_SANDBOX)
1733 # if defined(XP_LINUX)
1734 // On Linux, we have to support systems that can't use any sandboxing.
1738 // Pre-start audio before sandboxing; see bug 1443612.
1740 }
1746 }
1747 # elif defined(XP_WIN)
1749 // Library required for timely audio processing.
1751 // Libraries required by Network Security Services (NSS).
1754 // Library required by DirectWrite in some fall-back scenarios.
1756 // Libraries that are required for WMF software encoding.
1764 // Cache value that is retrieved from a registry entry.
1766 # if defined(DEBUG)
1767 // Library used in some debug testing.
1769 // Required for WMF shutdown, not required for opt due to quick exit.
1771 # endif
1772 }
1774 # elif defined(XP_MACOSX)
1777 # endif
1781 # if defined(XP_LINUX) && !defined(ANDROID)
1789 }
1793 // bidi is always of type PuppetBidiKeyboard* (because in the child, the only
1794 // possible implementation of nsIBidiKeyboard is PuppetBidiKeyboard).
1799 }
1801 }
1810 }
1831 }
1832 }
1842 // Recover if the BrowsingContext is missing for a new subframe. The
1843 // `ManagedEndpoint` instances will be automatically destroyed.
1846 }
1848 // (these are the only possible values of `reason` at this point)
1849 return browsingContext
1852 }
1857 nsAutoCString idString;
1860 idString))) {
1866 }
1867 }
1868 }
1873 "Logic in CreateDocumentViewerForActor currently requires "
1875 }
1877 // We'll happily accept any kind of IPCTabContext here; we don't need to
1878 // check that it's of a certain type for security purposes, because we
1879 // believe whatever the parent process tells us.
1887 }
1893 }
1899 // Bind the created BrowserChild to IPC to actually link the actor.
1902 }
1905 windowChild))) {
1907 }
1912 }
1913 });
1915 // Ensure that a BrowsingContext is set for our BrowserChild before
1916 // running `Init`.
1923 }
1929 }
1930 // Notify parent that we are ready to handle input events.
1933 }
1938 }
1943 "Default Constructor for PRemoteSpellcheckEngineChild should never be "
1946 }
1952 }
1959 }
1966 }
1971 }
1977 }
1981 }
1986 }
1993 }
1998 }
2003 }
2011 }
2015 // Some scripts listen for "app-startup" to start. However, in the content
2016 // process, this category runs before the ScriptPreloader is initialized so
2017 // these scripts wouldn't be added to the cache. Instead, if a script needs to
2018 // run on start up in the content process, it should listen for this category.
2023 }
2032 }
2034 }
2039 }
2042 #ifdef NS_PRINTING
2044 #else
2046 #endif
2047 }
2051 }
2055 }
2059 }
2065 }
2067 #ifdef MOZ_WEBRTC
2071 }
2076 }
2077 #endif
2089 }
2091 reset);
2093 }
2102 }
2119 }
2122 }
2131 }
2140 }
2144 }
2153 }
2162 }
2171 }
2182 }
2189 }
2196 }
2205 }
2207 }
2210 #if defined(XP_LINUX) && defined(MOZ_SANDBOX)
2212 #endif
2217 }
2222 }
2224 #ifndef NS_FREE_PERMANENT_DATA
2225 // In release builds, there's no point in the content process
2226 // going through the full XPCOM shutdown path, because it doesn't
2227 // keep persistent state.
2229 #else
2230 // Destroy our JSProcessActors, and reject any pending queries.
2233 # if defined(XP_WIN)
2241 }
2257 }
2258 }
2265 }
2283 }
2289 }
2296 }
2301 }
2306 }
2312 }
2318 }
2326 }
2335 }
2337 // aType == alertfinished, this alert is done and we can remove the
2338 // observer.
2341 });
2345 }
2348 }
2355 }
2360 }
2364 }
2366 }
2373 }
2380 }
2382 }
2393 StructuredCloneData data;
2397 }
2399 }
2409 }
2412 }
2418 }
2426 }
2432 mSharedData =
2435 }
2438 }
2444 }
2452 }
2460 }
2463 }
2471 }
2474 }
2481 }
2488 }
2490 }
2496 }
2498 }
2506 }
2508 }
2514 }
2520 }
2525 }
2536 // note we do not need to force mUserContextId to the default here because
2537 // the permission manager does that internally.
2538 nsAutoCString originNoSuffix;
2539 OriginAttributes attrs;
2550 // child processes don't care about modification time.
2559 }
2571 }
2577 }
2579 }
2582 #ifdef ACCESSIBILITY
2583 // Start accessibility in content process if it's running in chrome
2584 // process.
2588 }
2591 #ifdef ACCESSIBILITY
2592 // Try to shutdown accessibility in content process if it's shutting down in
2593 // chrome process.
2595 #endif
2597 }
2600 // Rebroadcast the "application-foreground"
2604 }
2606 }
2609 // Rebroadcast the "application-background"
2613 }
2615 }
2618 // Rebroadcast the "child-gc-request" so that workers will GC.
2622 }
2625 }
2628 // Rebroadcast the "child-cc-request" so that workers will CC.
2632 }
2635 }
2638 #ifdef DEBUG
2640 #endif
2642 }
2658 }
2663 // Allocation of preallocated processes that are still launching can
2664 // cause this
2666 }
2669 // Preallocated processes are type PREALLOC_REMOTE_TYPE; they may not
2670 // become a File: process, or Privileged About Content Process
2674 // prealloc->anything (but file) or web->web allowed, and no-change
2679 // Initial setting of remote type. Either to 'prealloc' or the actual
2680 // final type (if we didn't use a preallocated process)
2687 }
2688 }
2692 // Must do before SetProcessName
2695 // Update the process name so about:memory's process names are more obvious.
2707 // The profiler can sanitize out the eTLD+1
2708 nsDependentCSubstring etld =
2710 #ifdef NIGHTLY_BUILD
2712 #else
2715 #endif
2717 // The profiler can sanitize out the eTLD+1
2718 nsDependentCSubstring etld =
2722 // The profiler can sanitize out the eTLD+1
2723 nsDependentCSubstring etld =
2727 // else "prealloc" or "web" type -> "Web Content"
2729 }
2731 // Turn off Spectre mitigations in isolated web content processes.
2740 }
2742 // Use the prefix to avoid URIs from Fission isolated processes.
2747 }
2749 // A method to initialize anything we need during the preallocation phase
2753 // SetAcceptLanguages() needs to read localized strings (file access),
2754 // which is slow, so do this in prealloc
2756 }
2758 // Call RemoteTypePrefix() on the result to remove URIs if you want to use this
2759 // for telemetry.
2766 }
2778 // If we have received an already-revoked blobURL, we have to keep it alive
2779 // for a while (see BlobURLProtocolHandler) in order to support pending
2780 // operations such as navigation, download and so on.
2783 }
2784 }
2787 }
2795 }
2802 }
2809 }
2815 }
2832 // Record FOG data before the priority change.
2833 // Ignore the change if it's the first time we set the process priority.
2836 }
2847 // Note: keep this in sync with the JS shell (js/src/shell/js.cpp).
2852 #if defined(MOZ_MEMORY)
2855 }
2856 #endif
2863 }
2867 }
2868 }
2871 }
2880 }
2885 // Make sure aObserver isn't released while we wait for the parent
2889 }
2897 }
2907 }
2909 }
2915 }
2920 }
2923 }
2929 }
2934 }
2937 }
2944 }
2950 }
2952 }
2955 "If the domain policy is not active yet,"
2958 }
2966 }
2985 }
3004 }
3007 }
3012 }
3021 }
3022 }
3024 /* static */
3027 }
3033 // Bug 1755376: If we see "RecvShutdownConfirmedHP entry" often in
3034 // bug IPCError_ShutDownKill we might want to anticipate
3035 // ShutdownPhase::AppShutdownConfirmed to start here.
3038 }
3043 // Signal the ongoing shutdown to AppShutdown, this
3044 // will make abort nested SpinEventLoopUntilOrQuit loops
3055 }
3059 }
3064 // If we receive the shutdown message from within a nested event loop, we want
3065 // to wait for that event loop to finish. Otherwise we could prematurely
3066 // terminate an "unload" or "pagehide" event handler (which might be doing a
3067 // sync XHR, for example).
3071 // Note that we only have to check the recursion count for the current
3072 // cooperative thread. Since the Shutdown message is not labeled with a
3073 // SchedulerGroup, there can be no other cooperative threads doing work while
3074 // we're running.
3076 // We're in a nested event loop. Let's delay for an arbitrary period of
3077 // time (100ms) in the hopes that the event loop will have finished by
3078 // then.
3084 }
3088 #ifdef NIGHTLY_BUILD
3091 #endif
3096 }
3103 }
3113 ProfileAndAdditionalInformation shutdownProfileAndAdditionalInformation =
3130 }
3131 // Send the shutdown profile to the parent process through our own
3132 // message channel, which we know will survive for long enough.
3141 }
3145 }
3147 // Start a timer that will ensure we quickly exit after a reasonable period
3148 // of time. Prevents shutdown hangs after our connection to the parent
3149 // closes or when the parent is too busy to ever kill us.
3156 // Notify the parent that we are done with shutdown. This is sent with high
3157 // priority and will just flag we are done.
3160 // Now tell the parent to actually destroy our channel which will make end
3161 // our process. This is expected to be the last event the parent will
3162 // ever process for this ContentChild.
3167 }
3175 }
3177 PContentPermissionRequestChild*
3184 }
3192 }
3198 }
3205 }
3210 }
3218 }
3220 }
3228 }
3237 }
3244 }
3253 }
3261 }
3270 blobImpl);
3272 }
3277 aURI,
3280 }
3290 }
3299 }
3305 // This object can already been deleted in case DeleteGetFilesRequest has
3306 // been called when the response was sending by the parent.
3309 }
3324 }
3327 }
3329 }
3331 /* static */
3334 // If we're communicating with the same process or the UI process then we
3335 // want to crash normally. Otherwise we want to just warn as the other end
3336 // must be the GPU process and it crashing shouldn't be fatal for us.
3344 NS_WARNING(formattedMessage.get());
3345 }
3346 }
3348 PURLClassifierChild* ContentChild::AllocPURLClassifierChild(
3349 nsIPrincipal* aPrincipal, bool* aSuccess) {
3350 *aSuccess = true;
3351 return new URLClassifierChild();
3352 }
3354 bool ContentChild::DeallocPURLClassifierChild(PURLClassifierChild* aActor) {
3355 MOZ_ASSERT(aActor);
3356 delete aActor;
3357 return true;
3358 }
3360 PURLClassifierLocalChild* ContentChild::AllocPURLClassifierLocalChild(
3361 nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures) {
3362 return new URLClassifierLocalChild();
3363 }
3365 bool ContentChild::DeallocPURLClassifierLocalChild(
3366 PURLClassifierLocalChild* aActor) {
3367 MOZ_ASSERT(aActor);
3368 delete aActor;
3369 return true;
3370 }
3372 PSessionStorageObserverChild*
3373 ContentChild::AllocPSessionStorageObserverChild() {
3374 MOZ_CRASH(
3376 }
3378 bool ContentChild::DeallocPSessionStorageObserverChild(
3379 PSessionStorageObserverChild* aActor) {
3380 MOZ_ASSERT(aActor);
3382 delete aActor;
3383 return true;
3384 }
3386 mozilla::ipc::IPCResult ContentChild::RecvProvideAnonymousTemporaryFile(
3387 const uint64_t& aID, const FileDescOrError& aFDOrError) {
3388 mozilla::UniquePtr<AnonymousTemporaryFileCallback> callback;
3389 mPendingAnonymousTemporaryFiles.Remove(aID, &callback);
3390 MOZ_ASSERT(callback);
3392 PRFileDesc* prfile = nullptr;
3393 if (aFDOrError.type() == FileDescOrError::Tnsresult) {
3394 DebugOnly<nsresult> rv = aFDOrError.get_nsresult();
3395 MOZ_ASSERT(NS_FAILED(rv));
3396 } else {
3397 auto rawFD = aFDOrError.get_FileDescriptor().ClonePlatformHandle();
3398 prfile = PR_ImportFile(PROsfd(rawFD.release()));
3399 }
3400 (*callback)(prfile);
3401 return IPC_OK();
3402 }
3404 nsresult ContentChild::AsyncOpenAnonymousTemporaryFile(
3405 const AnonymousTemporaryFileCallback& aCallback) {
3406 MOZ_ASSERT(NS_IsMainThread());
3408 static uint64_t id = 0;
3409 auto newID = id++;
3410 if (!SendRequestAnonymousTemporaryFile(newID)) {
3411 return NS_ERROR_FAILURE;
3412 }
3414 // Remember the association with the callback.
3415 MOZ_ASSERT(!mPendingAnonymousTemporaryFiles.Get(newID));
3416 mPendingAnonymousTemporaryFiles.GetOrInsertNew(newID, aCallback);
3417 return NS_OK;
3418 }
3420 mozilla::ipc::IPCResult ContentChild::RecvSetPermissionsWithKey(
3421 const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms) {
3422 RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
3423 if (permManager) {
3424 permManager->SetPermissionsWithKey(aPermissionKey, aPerms);
3425 }
3427 return IPC_OK();
3428 }
3430 mozilla::ipc::IPCResult ContentChild::RecvRefreshScreens(
3431 nsTArray<ScreenDetails>&& aScreens) {
3432 ScreenManager& screenManager = ScreenManager::GetSingleton();
3433 screenManager.Refresh(std::move(aScreens));
3434 return IPC_OK();
3435 }
3437 mozilla::ipc::IPCResult ContentChild::RecvShareCodeCoverageMutex(
3438 CrossProcessMutexHandle aHandle) {
3439 #ifdef MOZ_CODE_COVERAGE
3440 CodeCoverageHandler::Init(std::move(aHandle));
3441 return IPC_OK();
3442 #else
3444 #endif
3445 }
3447 mozilla::ipc::IPCResult ContentChild::RecvFlushCodeCoverageCounters(
3448 FlushCodeCoverageCountersResolver&& aResolver) {
3449 #ifdef MOZ_CODE_COVERAGE
3450 CodeCoverageHandler::FlushCounters();
3451 aResolver(/* unused */ true);
3452 return IPC_OK();
3453 #else
3455 #endif
3456 }
3458 mozilla::ipc::IPCResult ContentChild::RecvSetInputEventQueueEnabled() {
3459 nsThreadManager::get().EnableMainThreadEventPrioritization();
3460 return IPC_OK();
3461 }
3463 mozilla::ipc::IPCResult ContentChild::RecvFlushInputEventQueue() {
3464 nsThreadManager::get().FlushInputEventPrioritization();
3465 return IPC_OK();
3466 }
3468 mozilla::ipc::IPCResult ContentChild::RecvSuspendInputEventQueue() {
3469 nsThreadManager::get().SuspendInputEventPrioritization();
3470 return IPC_OK();
3471 }
3473 mozilla::ipc::IPCResult ContentChild::RecvResumeInputEventQueue() {
3474 nsThreadManager::get().ResumeInputEventPrioritization();
3475 return IPC_OK();
3476 }
3478 mozilla::ipc::IPCResult ContentChild::RecvAddDynamicScalars(
3479 nsTArray<DynamicScalarDefinition>&& aDefs) {
3480 TelemetryIPC::AddDynamicScalarDefinitions(aDefs);
3481 return IPC_OK();
3482 }
3484 mozilla::ipc::IPCResult ContentChild::RecvCrossProcessRedirect(
3485 RedirectToRealChannelArgs&& aArgs,
3486 nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
3487 CrossProcessRedirectResolver&& aResolve) {
3488 nsCOMPtr<nsILoadInfo> loadInfo;
3489 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
3490 aArgs.loadInfo(), NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
3491 if (NS_FAILED(rv)) {
3493 return IPC_OK();
3494 }
3496 nsCOMPtr<nsIChannel> newChannel;
3497 MOZ_ASSERT((aArgs.loadStateInternalLoadFlags() &
3498 nsDocShell::InternalLoad::INTERNAL_LOAD_FLAGS_IS_SRCDOC) ||
3499 aArgs.srcdocData().IsVoid());
3500 rv = nsDocShell::CreateRealChannelForDocument(
3501 getter_AddRefs(newChannel), aArgs.uri(), loadInfo, nullptr,
3502 aArgs.newLoadFlags(), aArgs.srcdocData(), aArgs.baseUri());
3504 if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
3505 httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
3506 httpChannel->SetEarlyHintLinkType(aArgs.earlyHintLinkType());
3507 }
3509 // This is used to report any errors back to the parent by calling
3510 // CrossProcessRedirectFinished.
3511 RefPtr<HttpChannelChild> httpChild = do_QueryObject(newChannel);
3512 auto resolve = [=](const nsresult& aRv) {
3513 nsresult rv = aRv;
3514 if (httpChild) {
3515 rv = httpChild->CrossProcessRedirectFinished(rv);
3516 }
3517 aResolve(rv);
3518 };
3519 auto scopeExit = MakeScopeExit([&]() { resolve(rv); });
3521 if (NS_FAILED(rv)) {
3522 return IPC_OK();
3523 }
3525 if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel)) {
3526 rv = httpChannel->SetChannelId(aArgs.channelId());
3527 }
3528 if (NS_FAILED(rv)) {
3529 return IPC_OK();
3530 }
3532 rv = newChannel->SetOriginalURI(aArgs.originalURI());
3533 if (NS_FAILED(rv)) {
3534 return IPC_OK();
3535 }
3537 if (nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
3538 do_QueryInterface(newChannel)) {
3539 rv = httpChannelInternal->SetRedirectMode(aArgs.redirectMode());
3540 }
3541 if (NS_FAILED(rv)) {
3542 return IPC_OK();
3543 }
3545 if (aArgs.init()) {
3546 HttpBaseChannel::ReplacementChannelConfig config(std::move(*aArgs.init()));
3547 HttpBaseChannel::ConfigureReplacementChannel(
3548 newChannel, config,
3549 HttpBaseChannel::ReplacementReason::DocumentChannel);
3550 }
3552 if (aArgs.contentDisposition()) {
3553 newChannel->SetContentDisposition(*aArgs.contentDisposition());
3554 }
3556 if (aArgs.contentDispositionFilename()) {
3557 newChannel->SetContentDispositionFilename(
3558 *aArgs.contentDispositionFilename());
3559 }
3561 if (nsCOMPtr<nsIChildChannel> childChannel = do_QueryInterface(newChannel)) {
3562 // Connect to the parent if this is a remote channel. If it's entirely
3563 // handled locally, then we'll call AsyncOpen from the docshell when
3564 // we complete the setup
3565 rv = childChannel->ConnectParent(
3566 aArgs.registrarId()); // creates parent channel
3567 if (NS_FAILED(rv)) {
3568 return IPC_OK();
3569 }
3570 }
3572 // We need to copy the property bag before signaling that the channel
3573 // is ready so that the nsDocShell can retrieve the history data when called.
3574 if (nsCOMPtr<nsIWritablePropertyBag> bag = do_QueryInterface(newChannel)) {
3575 nsHashPropertyBag::CopyFrom(bag, aArgs.properties());
3576 }
3578 RefPtr<nsDocShellLoadState> loadState;
3579 rv = nsDocShellLoadState::CreateFromPendingChannel(
3580 newChannel, aArgs.loadIdentifier(), aArgs.registrarId(),
3581 getter_AddRefs(loadState));
3582 if (NS_WARN_IF(NS_FAILED(rv))) {
3583 return IPC_OK();
3584 }
3585 loadState->SetLoadFlags(aArgs.loadStateExternalLoadFlags());
3586 loadState->SetInternalLoadFlags(aArgs.loadStateInternalLoadFlags());
3587 if (IsValidLoadType(aArgs.loadStateLoadType())) {
3588 loadState->SetLoadType(aArgs.loadStateLoadType());
3589 }
3591 if (aArgs.loadingSessionHistoryInfo().isSome()) {
3592 loadState->SetLoadingSessionHistoryInfo(
3593 aArgs.loadingSessionHistoryInfo().ref());
3594 }
3595 if (aArgs.originalUriString().isSome()) {
3596 loadState->SetOriginalURIString(aArgs.originalUriString().ref());
3597 }
3599 RefPtr<ChildProcessChannelListener> processListener =
3600 ChildProcessChannelListener::GetSingleton();
3601 // The listener will call completeRedirectSetup or asyncOpen on the channel.
3602 processListener->OnChannelReady(loadState, aArgs.loadIdentifier(),
3603 std::move(aEndpoints), aArgs.timing(),
3604 std::move(resolve));
3605 scopeExit.release();
3607 // scopeExit will call CrossProcessRedirectFinished(rv) here
3608 return IPC_OK();
3609 }
3611 mozilla::ipc::IPCResult ContentChild::RecvStartDelayedAutoplayMediaComponents(
3612 const MaybeDiscarded<BrowsingContext>& aContext) {
3613 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3614 return IPC_OK();
3615 }
3617 aContext.get()->StartDelayedAutoplayMediaComponents();
3618 return IPC_OK();
3619 }
3621 mozilla::ipc::IPCResult ContentChild::RecvUpdateMediaControlAction(
3622 const MaybeDiscarded<BrowsingContext>& aContext,
3623 const MediaControlAction& aAction) {
3624 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3625 return IPC_OK();
3626 }
3628 ContentMediaControlKeyHandler::HandleMediaControlAction(aContext.get(),
3629 aAction);
3630 return IPC_OK();
3631 }
3633 mozilla::ipc::IPCResult ContentChild::RecvOnAllowAccessFor(
3634 const MaybeDiscarded<BrowsingContext>& aContext,
3635 const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
3636 const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
3637 aReason) {
3640 StorageAccessAPIHelper::OnAllowAccessFor(
3641 aContext.GetMaybeDiscarded(), aTrackingOrigin, aCookieBehavior, aReason);
3643 return IPC_OK();
3644 }
3646 mozilla::ipc::IPCResult ContentChild::RecvOnContentBlockingDecision(
3647 const MaybeDiscarded<BrowsingContext>& aContext,
3648 const ContentBlockingNotifier::BlockingDecision& aDecision,
3649 uint32_t aRejectedReason) {
3652 nsCOMPtr<nsPIDOMWindowOuter> outer = aContext.get()->GetDOMWindow();
3653 if (!outer) {
3654 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3657 return IPC_OK();
3658 }
3660 nsCOMPtr<nsPIDOMWindowInner> inner = outer->GetCurrentInnerWindow();
3661 if (!inner) {
3662 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3665 return IPC_OK();
3666 }
3668 ContentBlockingNotifier::OnDecision(inner, aDecision, aRejectedReason);
3669 return IPC_OK();
3670 }
3672 #ifdef NIGHTLY_BUILD
3673 void ContentChild::OnChannelReceivedMessage(const Message& aMsg) {
3674 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3675 mPendingInputEvents++;
3676 }
3677 }
3679 PContentChild::Result ContentChild::OnMessageReceived(const Message& aMsg) {
3680 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3681 DebugOnly<uint32_t> prevEvts = mPendingInputEvents--;
3682 MOZ_ASSERT(prevEvts > 0);
3683 }
3685 return PContentChild::OnMessageReceived(aMsg);
3686 }
3688 PContentChild::Result ContentChild::OnMessageReceived(
3689 const Message& aMsg, UniquePtr<Message>& aReply) {
3690 return PContentChild::OnMessageReceived(aMsg, aReply);
3691 }
3692 #endif
3694 mozilla::ipc::IPCResult ContentChild::RecvCreateBrowsingContext(
3695 uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit) {
3696 // We can't already have a BrowsingContext with this ID.
3697 if (RefPtr<BrowsingContext> existing = BrowsingContext::Get(aInit.mId)) {
3699 }
3701 RefPtr<WindowContext> parent = WindowContext::GetById(aInit.mParentId);
3702 if (!parent && aInit.mParentId != 0) {
3703 // Handle this case by ignoring the request, as parent must be in the
3704 // process of being discarded.
3705 // In the future it would be nice to avoid sending this message to the child
3706 // at all.
3708 return IPC_OK();
3709 }
3711 RefPtr<BrowsingContextGroup> group =
3712 BrowsingContextGroup::GetOrCreate(aGroupId);
3713 return BrowsingContext::CreateFromIPC(std::move(aInit), group, nullptr);
3714 }
3716 mozilla::ipc::IPCResult ContentChild::RecvDiscardBrowsingContext(
3717 const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
3718 DiscardBrowsingContextResolver&& aResolve) {
3719 if (BrowsingContext* context = aContext.GetMaybeDiscarded()) {
3720 if (aDoDiscard && !context->IsDiscarded()) {
3721 context->Detach(/* aFromIPC */ true);
3722 }
3723 context->AddDiscardListener(aResolve);
3724 return IPC_OK();
3725 }
3727 // Immediately resolve the promise, as we've received the message. This will
3728 // allow the parent process to discard references to this BC.
3729 aResolve(true);
3730 return IPC_OK();
3731 }
3733 mozilla::ipc::IPCResult ContentChild::RecvRegisterBrowsingContextGroup(
3734 uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits) {
3735 RefPtr<BrowsingContextGroup> group =
3736 BrowsingContextGroup::GetOrCreate(aGroupId);
3738 // Each of the initializers in aInits is sorted in pre-order, so our parent
3739 // should always be available before the element itself.
3740 for (auto& initUnion : aInits) {
3741 switch (initUnion.type()) {
3742 case SyncedContextInitializer::TBrowsingContextInitializer: {
3743 auto& init = initUnion.get_BrowsingContextInitializer();
3744 #ifdef DEBUG
3745 RefPtr<BrowsingContext> existing = BrowsingContext::Get(init.mId);
3748 RefPtr<WindowContext> parent = init.GetParent();
3749 MOZ_ASSERT_IF(parent, parent->Group() == group);
3750 #endif
3752 BrowsingContext::CreateFromIPC(std::move(init), group, nullptr);
3753 break;
3754 }
3755 case SyncedContextInitializer::TWindowContextInitializer: {
3756 auto& init = initUnion.get_WindowContextInitializer();
3757 #ifdef DEBUG
3758 RefPtr<WindowContext> existing =
3759 WindowContext::GetById(init.mInnerWindowId);
3761 RefPtr<BrowsingContext> parent =
3762 BrowsingContext::Get(init.mBrowsingContextId);
3763 MOZ_ASSERT(parent && parent->Group() == group);
3764 #endif
3766 WindowContext::CreateFromIPC(std::move(init));
3767 break;
3768 };
3769 default:
3770 MOZ_ASSERT_UNREACHABLE();
3771 }
3772 }
3774 return IPC_OK();
3775 }
3777 mozilla::ipc::IPCResult ContentChild::RecvDestroyBrowsingContextGroup(
3778 uint64_t aGroupId) {
3779 if (RefPtr<BrowsingContextGroup> group =
3780 BrowsingContextGroup::GetExisting(aGroupId)) {
3781 group->ChildDestroy();
3782 }
3783 return IPC_OK();
3784 }
3786 mozilla::ipc::IPCResult ContentChild::RecvWindowClose(
3787 const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller) {
3788 if (aContext.IsNullOrDiscarded()) {
3789 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3791 return IPC_OK();
3792 }
3794 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3795 if (!window) {
3796 MOZ_LOG(
3797 BrowsingContext::GetLog(), LogLevel::Debug,
3799 return IPC_OK();
3800 }
3802 // Call `GetDocument()` to force the document and its inner window to be
3803 // created, as it would be forced to be created if this call was being
3804 // performed in-process.
3805 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3806 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3809 return IPC_OK();
3810 }
3812 nsGlobalWindowOuter::Cast(window)->CloseOuter(aTrustedCaller);
3813 return IPC_OK();
3814 }
3816 mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(
3817 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3818 uint64_t aActionId) {
3819 if (aContext.IsNullOrDiscarded()) {
3820 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3822 return IPC_OK();
3823 }
3825 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3826 if (!window) {
3827 MOZ_LOG(
3828 BrowsingContext::GetLog(), LogLevel::Debug,
3830 return IPC_OK();
3831 }
3833 // Call `GetDocument()` to force the document and its inner window to be
3834 // created, as it would be forced to be created if this call was being
3835 // performed in-process.
3836 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3837 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3840 return IPC_OK();
3841 }
3843 nsGlobalWindowOuter::Cast(window)->FocusOuter(
3844 aCallerType, /* aFromOtherProcess */ true, aActionId);
3845 return IPC_OK();
3846 }
3848 mozilla::ipc::IPCResult ContentChild::RecvWindowBlur(
3849 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType) {
3850 if (aContext.IsNullOrDiscarded()) {
3851 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3853 return IPC_OK();
3854 }
3856 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3857 if (!window) {
3858 MOZ_LOG(
3859 BrowsingContext::GetLog(), LogLevel::Debug,
3861 return IPC_OK();
3862 }
3864 // Call `GetDocument()` to force the document and its inner window to be
3865 // created, as it would be forced to be created if this call was being
3866 // performed in-process.
3867 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3868 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3871 return IPC_OK();
3872 }
3874 nsGlobalWindowOuter::Cast(window)->BlurOuter(aCallerType);
3875 return IPC_OK();
3876 }
3878 mozilla::ipc::IPCResult ContentChild::RecvRaiseWindow(
3879 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3880 uint64_t aActionId) {
3881 if (aContext.IsNullOrDiscarded()) {
3882 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3884 return IPC_OK();
3885 }
3887 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3888 if (!window) {
3889 MOZ_LOG(
3890 BrowsingContext::GetLog(), LogLevel::Debug,
3892 return IPC_OK();
3893 }
3895 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3896 fm->RaiseWindow(window, aCallerType, aActionId);
3897 }
3898 return IPC_OK();
3899 }
3901 mozilla::ipc::IPCResult ContentChild::RecvAdjustWindowFocus(
3902 const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
3903 uint64_t aActionId, bool aShouldClearAncestorFocus,
3904 const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus) {
3905 if (aContext.IsNullOrDiscarded()) {
3906 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3908 return IPC_OK();
3909 }
3911 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3912 RefPtr<BrowsingContext> bc = aContext.get();
3913 RefPtr<BrowsingContext> ancestor =
3914 aAncestorBrowsingContextToFocus.IsNullOrDiscarded()
3915 ? nullptr
3916 : aAncestorBrowsingContextToFocus.get();
3917 fm->AdjustInProcessWindowFocus(bc, false, aIsVisible, aActionId,
3918 aShouldClearAncestorFocus, ancestor);
3919 }
3920 return IPC_OK();
3921 }
3923 mozilla::ipc::IPCResult ContentChild::RecvClearFocus(
3924 const MaybeDiscarded<BrowsingContext>& aContext) {
3925 if (aContext.IsNullOrDiscarded()) {
3926 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3928 return IPC_OK();
3929 }
3931 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3932 if (!window) {
3933 MOZ_LOG(
3934 BrowsingContext::GetLog(), LogLevel::Debug,
3936 return IPC_OK();
3937 }
3939 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3940 fm->ClearFocus(window);
3941 }
3942 return IPC_OK();
3943 }
3945 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedBrowsingContext(
3946 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3947 if (aContext.IsNullOrDiscarded()) {
3948 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3950 return IPC_OK();
3951 }
3953 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3954 if (fm) {
3955 fm->SetFocusedBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3956 }
3957 return IPC_OK();
3958 }
3960 mozilla::ipc::IPCResult ContentChild::RecvSetActiveBrowsingContext(
3961 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3962 if (aContext.IsNullOrDiscarded()) {
3963 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3965 return IPC_OK();
3966 }
3968 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3969 if (fm) {
3970 fm->SetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3971 }
3972 return IPC_OK();
3973 }
3975 mozilla::ipc::IPCResult ContentChild::RecvAbortOrientationPendingPromises(
3976 const MaybeDiscarded<BrowsingContext>& aContext) {
3977 if (aContext.IsNullOrDiscarded()) {
3978 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3980 return IPC_OK();
3981 }
3983 dom::ScreenOrientation::AbortInProcessOrientationPromises(aContext.get());
3984 return IPC_OK();
3985 }
3987 mozilla::ipc::IPCResult ContentChild::RecvUnsetActiveBrowsingContext(
3988 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3989 if (aContext.IsNullOrDiscarded()) {
3990 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3992 return IPC_OK();
3993 }
3995 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3996 if (fm) {
3997 fm->UnsetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3998 }
3999 return IPC_OK();
4000 }
4002 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedElement(
4003 const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus) {
4004 if (aContext.IsNullOrDiscarded()) {
4005 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4007 return IPC_OK();
4008 }
4010 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
4011 if (!window) {
4012 MOZ_LOG(
4013 BrowsingContext::GetLog(), LogLevel::Debug,
4015 return IPC_OK();
4016 }
4018 window->SetFocusedElement(nullptr, 0, aNeedsFocus);
4019 return IPC_OK();
4020 }
4022 mozilla::ipc::IPCResult ContentChild::RecvFinalizeFocusOuter(
4023 const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
4024 CallerType aCallerType) {
4025 if (aContext.IsNullOrDiscarded()) {
4026 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4028 return IPC_OK();
4029 }
4031 if (Element* frame = aContext.get()->GetEmbedderElement()) {
4032 nsContentUtils::RequestFrameFocus(*frame, aCanFocus, aCallerType);
4033 }
4035 return IPC_OK();
4036 }
4038 mozilla::ipc::IPCResult ContentChild::RecvBlurToChild(
4039 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4040 const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
4041 const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
4042 bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId) {
4043 if (aFocusedBrowsingContext.IsNullOrDiscarded()) {
4044 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4046 return IPC_OK();
4047 }
4049 RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
4050 if (MOZ_UNLIKELY(!fm)) {
4051 return IPC_OK();
4052 }
4054 RefPtr<BrowsingContext> toClear = aBrowsingContextToClear.IsDiscarded()
4055 ? nullptr
4056 : aBrowsingContextToClear.get();
4057 RefPtr<BrowsingContext> toFocus =
4058 aAncestorBrowsingContextToFocus.IsDiscarded()
4059 ? nullptr
4060 : aAncestorBrowsingContextToFocus.get();
4062 RefPtr<BrowsingContext> focusedBrowsingContext =
4063 aFocusedBrowsingContext.get();
4065 fm->BlurFromOtherProcess(focusedBrowsingContext, toClear, toFocus,
4066 aIsLeavingDocument, aAdjustWidget, aActionId);
4067 return IPC_OK();
4068 }
4070 mozilla::ipc::IPCResult ContentChild::RecvSetupFocusedAndActive(
4071 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4072 uint64_t aActionIdForFocused,
4073 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4074 uint64_t aActionIdForActive) {
4075 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4076 if (fm) {
4077 if (!aActiveBrowsingContext.IsNullOrDiscarded()) {
4078 fm->SetActiveBrowsingContextFromOtherProcess(aActiveBrowsingContext.get(),
4079 aActionIdForActive);
4080 }
4081 if (!aFocusedBrowsingContext.IsNullOrDiscarded()) {
4082 fm->SetFocusedBrowsingContextFromOtherProcess(
4083 aFocusedBrowsingContext.get(), aActionIdForFocused);
4084 }
4085 }
4086 return IPC_OK();
4087 }
4089 mozilla::ipc::IPCResult ContentChild::RecvReviseActiveBrowsingContext(
4090 uint64_t aOldActionId,
4091 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4092 uint64_t aNewActionId) {
4093 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4094 if (fm && !aActiveBrowsingContext.IsNullOrDiscarded()) {
4095 fm->ReviseActiveBrowsingContext(aOldActionId, aActiveBrowsingContext.get(),
4096 aNewActionId);
4097 }
4098 return IPC_OK();
4099 }
4101 mozilla::ipc::IPCResult ContentChild::RecvReviseFocusedBrowsingContext(
4102 uint64_t aOldActionId,
4103 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4104 uint64_t aNewActionId) {
4105 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4106 if (fm && !aFocusedBrowsingContext.IsNullOrDiscarded()) {
4107 fm->ReviseFocusedBrowsingContext(
4108 aOldActionId, aFocusedBrowsingContext.get(), aNewActionId);
4109 }
4110 return IPC_OK();
4111 }
4113 mozilla::ipc::IPCResult ContentChild::RecvMaybeExitFullscreen(
4114 const MaybeDiscarded<BrowsingContext>& aContext) {
4115 if (aContext.IsNullOrDiscarded()) {
4116 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4118 return IPC_OK();
4119 }
4121 nsIDocShell* shell = aContext.get()->GetDocShell();
4122 if (!shell) {
4123 return IPC_OK();
4124 }
4126 Document* doc = shell->GetDocument();
4127 if (doc && doc->GetFullscreenElement()) {
4128 Document::AsyncExitFullscreen(doc);
4129 }
4131 return IPC_OK();
4132 }
4134 mozilla::ipc::IPCResult ContentChild::RecvWindowPostMessage(
4135 const MaybeDiscarded<BrowsingContext>& aContext,
4136 const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData) {
4137 if (aContext.IsNullOrDiscarded()) {
4138 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4140 return IPC_OK();
4141 }
4143 RefPtr<nsGlobalWindowOuter> window =
4144 nsGlobalWindowOuter::Cast(aContext.get()->GetDOMWindow());
4145 if (!window) {
4146 MOZ_LOG(
4147 BrowsingContext::GetLog(), LogLevel::Debug,
4149 return IPC_OK();
4150 }
4152 nsCOMPtr<nsIPrincipal> providedPrincipal;
4153 if (!window->GetPrincipalForPostMessage(
4154 aData.targetOrigin(), aData.targetOriginURI(),
4155 aData.callerPrincipal(), *aData.subjectPrincipal(),
4156 getter_AddRefs(providedPrincipal))) {
4157 return IPC_OK();
4158 }
4160 // Call `GetDocument()` to force the document and its inner window to be
4161 // created, as it would be forced to be created if this call was being
4162 // performed in-process.
4163 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
4164 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4167 return IPC_OK();
4168 }
4170 // It's OK if `sourceBc` has already been discarded, so long as we can
4171 // continue to wrap it.
4172 RefPtr<BrowsingContext> sourceBc = aData.source().GetMaybeDiscarded();
4174 // Create and asynchronously dispatch a runnable which will handle actual DOM
4175 // event creation and dispatch.
4176 RefPtr<PostMessageEvent> event =
4177 new PostMessageEvent(sourceBc, aData.origin(), window, providedPrincipal,
4178 aData.innerWindowId(), aData.callerURI(),
4179 aData.scriptLocation(), aData.isFromPrivateWindow());
4180 event->UnpackFrom(aMessage);
4182 event->DispatchToTargetThread(IgnoredErrorResult());
4183 return IPC_OK();
4184 }
4186 mozilla::ipc::IPCResult ContentChild::RecvCommitBrowsingContextTransaction(
4187 const MaybeDiscarded<BrowsingContext>& aContext,
4188 BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4189 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4190 }
4192 mozilla::ipc::IPCResult ContentChild::RecvCommitWindowContextTransaction(
4193 const MaybeDiscarded<WindowContext>& aContext,
4194 WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4195 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4196 }
4198 mozilla::ipc::IPCResult ContentChild::RecvCreateWindowContext(
4199 WindowContext::IPCInitializer&& aInit) {
4200 RefPtr<BrowsingContext> bc = BrowsingContext::Get(aInit.mBrowsingContextId);
4201 if (!bc) {
4202 // Handle this case by ignoring the request, as bc must be in the process of
4203 // being discarded.
4204 // In the future it would be nice to avoid sending this message to the child
4205 // at all.
4207 return IPC_OK();
4208 }
4210 WindowContext::CreateFromIPC(std::move(aInit));
4211 return IPC_OK();
4212 }
4214 mozilla::ipc::IPCResult ContentChild::RecvDiscardWindowContext(
4215 uint64_t aContextId, DiscardWindowContextResolver&& aResolve) {
4216 // Resolve immediately to acknowledge call
4217 aResolve(true);
4219 RefPtr<WindowContext> window = WindowContext::GetById(aContextId);
4220 if (NS_WARN_IF(!window) || NS_WARN_IF(window->IsDiscarded())) {
4221 return IPC_OK();
4222 }
4224 window->Discard();
4225 return IPC_OK();
4226 }
4228 mozilla::ipc::IPCResult ContentChild::RecvScriptError(
4229 const nsString& aMessage, const nsString& aSourceName,
4230 const nsString& aSourceLine, const uint32_t& aLineNumber,
4231 const uint32_t& aColNumber, const uint32_t& aFlags,
4232 const nsCString& aCategory, const bool& aFromPrivateWindow,
4233 const uint64_t& aInnerWindowId, const bool& aFromChromeContext) {
4234 nsresult rv = NS_OK;
4235 nsCOMPtr<nsIConsoleService> consoleService =
4236 do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
4239 nsCOMPtr<nsIScriptError> scriptError(
4240 do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
4241 NS_ENSURE_TRUE(scriptError,
4244 scriptError->InitWithWindowID(aMessage, aSourceName, aSourceLine, aLineNumber,
4245 aColNumber, aFlags, aCategory, aInnerWindowId,
4246 aFromChromeContext);
4247 rv = consoleService->LogMessage(scriptError);
4250 return IPC_OK();
4251 }
4253 mozilla::ipc::IPCResult ContentChild::RecvReportFrameTimingData(
4254 const LoadInfoArgs& loadInfoArgs, const nsString& entryName,
4255 const nsString& initiatorType, UniquePtr<PerformanceTimingData>&& aData) {
4256 if (!aData) {
4258 }
4260 nsCOMPtr<nsILoadInfo> loadInfo;
4261 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
4262 loadInfoArgs, NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
4263 if (NS_FAILED(rv)) {
4265 return IPC_OK();
4266 }
4268 // It is important to call LoadInfo::GetPerformanceStorage instead of simply
4269 // getting the performance object via the innerWindowID in order to perform
4270 // necessary cross origin checks.
4271 if (PerformanceStorage* storage = loadInfo->GetPerformanceStorage()) {
4272 storage->AddEntry(entryName, initiatorType, std::move(aData));
4273 }
4274 return IPC_OK();
4275 }
4277 mozilla::ipc::IPCResult ContentChild::RecvLoadURI(
4278 const MaybeDiscarded<BrowsingContext>& aContext,
4279 nsDocShellLoadState* aLoadState, bool aSetNavigating,
4280 LoadURIResolver&& aResolve) {
4281 auto resolveOnExit = MakeScopeExit([&] { aResolve(true); });
4283 if (aContext.IsNullOrDiscarded()) {
4284 return IPC_OK();
4285 }
4286 RefPtr<BrowsingContext> context = aContext.get();
4287 if (!context->IsInProcess()) {
4288 // The DocShell has been torn down or the BrowsingContext has changed
4289 // process in the middle of the load request. There's not much we can do at
4290 // this point, so just give up.
4291 return IPC_OK();
4292 }
4294 context->LoadURI(aLoadState, aSetNavigating);
4296 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4297 BrowserChild* bc = BrowserChild::GetFrom(window);
4298 if (bc) {
4299 bc->NotifyNavigationFinished();
4300 }
4302 #ifdef MOZ_CRASHREPORTER
4303 if (CrashReporter::GetEnabled()) {
4304 nsCOMPtr<nsIURI> annotationURI;
4306 nsresult rv = NS_MutateURI(aLoadState->URI())
4308 .Finalize(annotationURI);
4310 if (NS_FAILED(rv)) {
4311 // Ignore failures on about: URIs.
4312 annotationURI = aLoadState->URI();
4313 }
4315 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4316 annotationURI->GetSpecOrDefault());
4317 }
4318 #endif
4320 return IPC_OK();
4321 }
4323 mozilla::ipc::IPCResult ContentChild::RecvInternalLoad(
4324 nsDocShellLoadState* aLoadState) {
4325 if (!aLoadState->Target().IsEmpty() ||
4326 aLoadState->TargetBrowsingContext().IsNull()) {
4328 }
4329 if (aLoadState->TargetBrowsingContext().IsDiscarded()) {
4330 return IPC_OK();
4331 }
4332 RefPtr<BrowsingContext> context = aLoadState->TargetBrowsingContext().get();
4334 context->InternalLoad(aLoadState);
4336 #ifdef MOZ_CRASHREPORTER
4337 if (CrashReporter::GetEnabled()) {
4338 nsCOMPtr<nsIURI> annotationURI;
4340 nsresult rv = NS_MutateURI(aLoadState->URI())
4342 .Finalize(annotationURI);
4344 if (NS_FAILED(rv)) {
4345 // Ignore failures on about: URIs.
4346 annotationURI = aLoadState->URI();
4347 }
4349 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4350 annotationURI->GetSpecOrDefault());
4351 }
4352 #endif
4354 return IPC_OK();
4355 }
4357 mozilla::ipc::IPCResult ContentChild::RecvDisplayLoadError(
4358 const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI) {
4359 if (aContext.IsNullOrDiscarded()) {
4360 return IPC_OK();
4361 }
4362 RefPtr<BrowsingContext> context = aContext.get();
4364 context->DisplayLoadError(aURI);
4366 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4367 BrowserChild* bc = BrowserChild::GetFrom(window);
4368 if (bc) {
4369 bc->NotifyNavigationFinished();
4370 }
4371 return IPC_OK();
4372 }
4374 mozilla::ipc::IPCResult ContentChild::RecvHistoryCommitIndexAndLength(
4375 const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
4376 const uint32_t& aLength, const nsID& aChangeID) {
4377 if (!aContext.IsNullOrDiscarded()) {
4378 ChildSHistory* shistory = aContext.get()->GetChildSessionHistory();
4379 if (shistory) {
4380 shistory->SetIndexAndLength(aIndex, aLength, aChangeID);
4381 }
4382 }
4383 return IPC_OK();
4384 }
4386 mozilla::ipc::IPCResult ContentChild::RecvGetLayoutHistoryState(
4387 const MaybeDiscarded<BrowsingContext>& aContext,
4388 GetLayoutHistoryStateResolver&& aResolver) {
4389 nsCOMPtr<nsILayoutHistoryState> state;
4390 nsIDocShell* docShell;
4391 mozilla::Maybe<mozilla::dom::Wireframe> wireframe;
4392 if (!aContext.IsNullOrDiscarded() &&
4393 (docShell = aContext.get()->GetDocShell())) {
4394 docShell->PersistLayoutHistoryState();
4395 docShell->GetLayoutHistoryState(getter_AddRefs(state));
4396 wireframe = static_cast<nsDocShell*>(docShell)->GetWireframe();
4397 }
4398 aResolver(
4399 std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&>(
4400 state, wireframe));
4402 return IPC_OK();
4403 }
4405 mozilla::ipc::IPCResult ContentChild::RecvDispatchLocationChangeEvent(
4406 const MaybeDiscarded<BrowsingContext>& aContext) {
4407 if (!aContext.IsNullOrDiscarded() && aContext.get()->GetDocShell()) {
4408 aContext.get()->GetDocShell()->DispatchLocationChangeEvent();
4409 }
4410 return IPC_OK();
4411 }
4413 mozilla::ipc::IPCResult ContentChild::RecvDispatchBeforeUnloadToSubtree(
4414 const MaybeDiscarded<BrowsingContext>& aStartingAt,
4415 DispatchBeforeUnloadToSubtreeResolver&& aResolver) {
4416 if (aStartingAt.IsNullOrDiscarded()) {
4417 aResolver(nsIDocumentViewer::eAllowNavigation);
4418 } else {
4419 DispatchBeforeUnloadToSubtree(aStartingAt.get(), std::move(aResolver));
4420 }
4421 return IPC_OK();
4422 }
4424 mozilla::ipc::IPCResult ContentChild::RecvInitNextGenLocalStorageEnabled(
4425 const bool& aEnabled) {
4426 mozilla::dom::RecvInitNextGenLocalStorageEnabled(aEnabled);
4428 return IPC_OK();
4429 }
4431 /* static */ void ContentChild::DispatchBeforeUnloadToSubtree(
4432 BrowsingContext* aStartingAt,
4433 const DispatchBeforeUnloadToSubtreeResolver& aResolver) {
4434 bool resolved = false;
4436 aStartingAt->PreOrderWalk([&](dom::BrowsingContext* aBC) {
4437 if (aBC->GetDocShell()) {
4438 nsCOMPtr<nsIDocumentViewer> viewer;
4439 aBC->GetDocShell()->GetDocViewer(getter_AddRefs(viewer));
4440 if (viewer &&
4441 viewer->DispatchBeforeUnload() ==
4442 nsIDocumentViewer::eRequestBlockNavigation &&
4443 !resolved) {
4444 // Send our response as soon as we find any blocker, so that we can show
4445 // the permit unload prompt as soon as possible, without giving
4446 // subsequent handlers a chance to delay it.
4447 aResolver(nsIDocumentViewer::eRequestBlockNavigation);
4448 resolved = true;
4449 }
4450 }
4451 });
4453 if (!resolved) {
4454 aResolver(nsIDocumentViewer::eAllowNavigation);
4455 }
4456 }
4458 mozilla::ipc::IPCResult ContentChild::RecvGoBack(
4459 const MaybeDiscarded<BrowsingContext>& aContext,
4460 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4461 bool aUserActivation) {
4462 if (aContext.IsNullOrDiscarded()) {
4463 return IPC_OK();
4464 }
4465 BrowsingContext* bc = aContext.get();
4467 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4468 if (aCancelContentJSEpoch) {
4469 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4470 }
4471 docShell->GoBack(aRequireUserInteraction, aUserActivation);
4473 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4474 browserChild->NotifyNavigationFinished();
4475 }
4476 }
4478 return IPC_OK();
4479 }
4481 mozilla::ipc::IPCResult ContentChild::RecvGoForward(
4482 const MaybeDiscarded<BrowsingContext>& aContext,
4483 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4484 bool aUserActivation) {
4485 if (aContext.IsNullOrDiscarded()) {
4486 return IPC_OK();
4487 }
4488 BrowsingContext* bc = aContext.get();
4490 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4491 if (aCancelContentJSEpoch) {
4492 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4493 }
4494 docShell->GoForward(aRequireUserInteraction, aUserActivation);
4496 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4497 browserChild->NotifyNavigationFinished();
4498 }
4499 }
4501 return IPC_OK();
4502 }
4504 mozilla::ipc::IPCResult ContentChild::RecvGoToIndex(
4505 const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
4506 const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation) {
4507 if (aContext.IsNullOrDiscarded()) {
4508 return IPC_OK();
4509 }
4510 BrowsingContext* bc = aContext.get();
4512 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4513 if (aCancelContentJSEpoch) {
4514 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4515 }
4516 docShell->GotoIndex(aIndex, aUserActivation);
4518 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4519 browserChild->NotifyNavigationFinished();
4520 }
4521 }
4523 return IPC_OK();
4524 }
4526 mozilla::ipc::IPCResult ContentChild::RecvReload(
4527 const MaybeDiscarded<BrowsingContext>& aContext,
4528 const uint32_t aReloadFlags) {
4529 if (aContext.IsNullOrDiscarded()) {
4530 return IPC_OK();
4531 }
4532 BrowsingContext* bc = aContext.get();
4534 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4535 docShell->Reload(aReloadFlags);
4536 }
4538 return IPC_OK();
4539 }
4541 mozilla::ipc::IPCResult ContentChild::RecvStopLoad(
4542 const MaybeDiscarded<BrowsingContext>& aContext,
4543 const uint32_t aStopFlags) {
4544 if (aContext.IsNullOrDiscarded()) {
4545 return IPC_OK();
4546 }
4547 BrowsingContext* bc = aContext.get();
4549 if (auto* docShell = nsDocShell::Cast(bc->GetDocShell())) {
4550 docShell->Stop(aStopFlags);
4551 }
4553 return IPC_OK();
4554 }
4556 #if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
4557 mozilla::ipc::IPCResult ContentChild::RecvInitSandboxTesting(
4558 Endpoint<PSandboxTestingChild>&& aEndpoint) {
4559 if (!SandboxTestingChild::Initialize(std::move(aEndpoint))) {
4560 return IPC_FAIL(
4562 }
4563 return IPC_OK();
4564 }
4565 #endif
4567 NS_IMETHODIMP ContentChild::GetChildID(uint64_t* aOut) {
4568 *aOut = mID;
4569 return NS_OK;
4570 }
4572 NS_IMETHODIMP ContentChild::GetActor(const nsACString& aName, JSContext* aCx,
4573 JSProcessActorChild** retval) {
4574 ErrorResult error;
4575 RefPtr<JSProcessActorChild> actor =
4576 JSActorManager::GetActor(aCx, aName, error)
4577 .downcast<JSProcessActorChild>();
4578 if (error.MaybeSetPendingException(aCx)) {
4579 return NS_ERROR_FAILURE;
4580 }
4581 actor.forget(retval);
4582 return NS_OK;
4583 }
4585 NS_IMETHODIMP ContentChild::GetExistingActor(const nsACString& aName,
4586 JSProcessActorChild** retval) {
4587 RefPtr<JSProcessActorChild> actor =
4588 JSActorManager::GetExistingActor(aName).downcast<JSProcessActorChild>();
4589 actor.forget(retval);
4590 return NS_OK;
4591 }
4593 already_AddRefed<JSActor> ContentChild::InitJSActor(
4594 JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
4595 ErrorResult& aRv) {
4596 RefPtr<JSProcessActorChild> actor;
4597 if (aMaybeActor.get()) {
4598 aRv = UNWRAP_OBJECT(JSProcessActorChild, aMaybeActor.get(), actor);
4599 if (aRv.Failed()) {
4600 return nullptr;
4601 }
4602 } else {
4603 actor = new JSProcessActorChild();
4604 }
4606 MOZ_RELEASE_ASSERT(!actor->Manager(),
4608 actor->Init(aName, this);
4609 return actor.forget();
4610 }
4612 IPCResult ContentChild::RecvRawMessage(const JSActorMessageMeta& aMeta,
4613 const Maybe<ClonedMessageData>& aData,
4614 const Maybe<ClonedMessageData>& aStack) {
4615 Maybe<StructuredCloneData> data;
4616 if (aData) {
4617 data.emplace();
4618 data->BorrowFromClonedMessageData(*aData);
4619 }
4620 Maybe<StructuredCloneData> stack;
4621 if (aStack) {
4622 stack.emplace();
4623 stack->BorrowFromClonedMessageData(*aStack);
4624 }
4625 ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
4626 return IPC_OK();
4627 }
4629 NS_IMETHODIMP ContentChild::GetCanSend(bool* aCanSend) {
4630 *aCanSend = CanSend();
4631 return NS_OK;
4632 }
4634 ContentChild* ContentChild::AsContentChild() { return this; }
4636 JSActorManager* ContentChild::AsJSActorManager() { return this; }
4638 IPCResult ContentChild::RecvFlushFOGData(FlushFOGDataResolver&& aResolver) {
4639 glean::FlushFOGData(std::move(aResolver));
4640 return IPC_OK();
4641 }
4643 IPCResult ContentChild::RecvUpdateMediaCodecsSupported(
4644 RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
4645 RemoteDecoderManagerChild::SetSupported(aLocation, aSupported);
4647 return IPC_OK();
4648 }
4650 void ContentChild::ConfigureThreadPerformanceHints(
4651 const hal::ProcessPriority& aPriority) {
4652 if (aPriority >= hal::PROCESS_PRIORITY_FOREGROUND) {
4653 static bool canUsePerformanceHintSession = true;
4654 if (!mPerformanceHintSession && canUsePerformanceHintSession) {
4655 nsTArray<PlatformThreadHandle> threads;
4656 Servo_ThreadPool_GetThreadHandles(&threads);
4657 #ifdef XP_WIN
4658 threads.AppendElement(GetCurrentThread());
4659 #else
4660 threads.AppendElement(pthread_self());
4661 #endif
4663 mPerformanceHintSession = hal::CreatePerformanceHintSession(
4664 threads, GetPerformanceHintTarget(TimeDuration::FromMilliseconds(
4665 nsRefreshDriver::DefaultInterval())));
4667 // Avoid repeatedly attempting to create a session if it is not
4668 // supported.
4669 canUsePerformanceHintSession = mPerformanceHintSession != nullptr;
4670 }
4672 #ifdef MOZ_WIDGET_ANDROID
4673 // On Android if we are unable to use PerformanceHintManager then fall back
4674 // to setting the stylo threads' affinities to the performant cores. Android
4675 // automatically sets each thread's affinity to all cores when a process is
4676 // foregrounded, and to a subset of cores when the process is backgrounded.
4677 // We must therefore override this each time the process is foregrounded,
4678 // but we don't have to do anything when backgrounded.
4679 if (!mPerformanceHintSession) {
4680 if (const auto& cpuInfo = hal::GetHeterogeneousCpuInfo()) {
4681 // If CPUs are homogeneous there is no point setting affinity.
4682 if (cpuInfo->mBigCpus.Count() != cpuInfo->mTotalNumCpus) {
4683 BitSet<hal::HeterogeneousCpuInfo::MAX_CPUS> cpus = cpuInfo->mBigCpus;
4684 if (cpus.Count() < 2) {
4685 // From testing on a variety of devices it appears using only the
4686 // big cores gives best performance when there are 2 or more big
4687 // cores. If there are fewer than 2 big cores then additionally
4688 // using the medium cores performs better.
4689 cpus |= cpuInfo->mMediumCpus;
4690 }
4692 static_assert(
4693 hal::HeterogeneousCpuInfo::MAX_CPUS <= CPU_SETSIZE,
4696 cpu_set_t cpuset;
4697 CPU_ZERO(&cpuset);
4698 for (size_t i = 0; i < cpuInfo->mTotalNumCpus; i++) {
4699 if (cpus.Test(i)) {
4700 CPU_SET(i, &cpuset);
4701 }
4702 }
4704 // Only set the affinity for the stylo threads, not the main thread.
4705 // Testing showed no difference in performance between the two
4706 // options, and as newly spawned threads automatically inherit their
4707 // parent's affinity mask there may be unintended consequences to
4708 // setting the main thread affinity.
4709 nsTArray<PlatformThreadHandle> threads;
4710 Servo_ThreadPool_GetThreadHandles(&threads);
4711 for (pthread_t thread : threads) {
4712 int ret = sched_setaffinity(pthread_gettid_np(thread),
4713 sizeof(cpu_set_t), &cpuset);
4714 // Occasionally sched_setaffinity fails, presumably due to a race
4715 // between us receiving the process foreground signal and whatever
4716 // is responsible for restricting which processes can use certain
4717 // cores. Trying again in a runnable seems to do the trick, but if
4718 // that still fails it's not the end of the world.
4719 if (ret < 0) {
4720 NS_DispatchToCurrentThread(NS_NewRunnableFunction(
4722 [threads = std::move(threads), cpuset] {
4723 for (pthread_t thread : threads) {
4724 sched_setaffinity(pthread_gettid_np(thread),
4725 sizeof(cpu_set_t), &cpuset);
4726 }
4727 }));
4728 break;
4729 }
4730 }
4731 }
4732 }
4733 }
4734 #endif
4735 } else {
4736 mPerformanceHintSession = nullptr;
4737 }
4738 }
4740 } // namespace dom
4742 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
4746 NS_IMETHODIMP
4747 OpenBSDFindPledgeUnveilFilePath(const char* file, nsACString& result) {
4748 struct stat st;
4750 // Allow overriding files in /etc/$MOZ_APP_NAME
4752 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4753 return NS_OK;
4754 }
4756 // Or look in the system default directory
4757 result.Assign(nsPrintfCString(
4759 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4760 return NS_OK;
4761 }
4764 }
4766 NS_IMETHODIMP
4767 OpenBSDPledgePromises(const nsACString& aPath) {
4768 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4769 // a lot of setup before they are supported and we want to pledge early on
4770 // before all of that, so read the file directly
4771 std::ifstream input(PromiseFlatCString(aPath).get());
4773 // Build up one line of pledge promises without comments
4774 nsAutoCString promises;
4775 bool disabled = false;
4776 int linenum = 0;
4777 for (std::string tLine; std::getline(input, tLine);) {
4778 nsAutoCString line(tLine.c_str());
4779 linenum++;
4781 // Cut off any comments at the end of the line, also catches lines
4782 // that are entirely a comment
4784 if (hash >= 0) {
4785 line = Substring(line, 0, hash);
4786 }
4787 line.CompressWhitespace(true, true);
4788 if (line.IsEmpty()) {
4789 continue;
4790 }
4792 if (linenum == 1 && line.EqualsLiteral("disable")) {
4793 disabled = true;
4794 break;
4795 }
4797 if (!promises.IsEmpty()) {
4798 promises.Append(" ");
4799 }
4800 promises.Append(line);
4801 }
4802 input.close();
4804 if (disabled) {
4805 warnx("%s: disabled", PromiseFlatCString(aPath).get());
4806 } else {
4807 MOZ_LOG(
4808 sPledgeLog, LogLevel::Debug,
4810 if (pledge(promises.get(), nullptr) != 0) {
4811 err(1, "%s: pledge(%s) failed", PromiseFlatCString(aPath).get(),
4812 promises.get());
4813 }
4814 }
4816 return NS_OK;
4817 }
4819 void ExpandUnveilPath(nsAutoCString& path) {
4820 // Expand $XDG_RUNTIME_DIR to the environment variable, or ~/.cache
4821 nsCString xdgRuntimeDir(PR_GetEnv("XDG_RUNTIME_DIR"));
4822 if (xdgRuntimeDir.IsEmpty()) {
4823 xdgRuntimeDir = "~/.cache";
4824 }
4825 path.ReplaceSubstring("$XDG_RUNTIME_DIR", xdgRuntimeDir.get());
4827 // Expand $XDG_CONFIG_HOME to the environment variable, or ~/.config
4828 nsCString xdgConfigHome(PR_GetEnv("XDG_CONFIG_HOME"));
4829 if (xdgConfigHome.IsEmpty()) {
4830 xdgConfigHome = "~/.config";
4831 }
4832 path.ReplaceSubstring("$XDG_CONFIG_HOME", xdgConfigHome.get());
4834 // Expand $XDG_CACHE_HOME to the environment variable, or ~/.cache
4835 nsCString xdgCacheHome(PR_GetEnv("XDG_CACHE_HOME"));
4836 if (xdgCacheHome.IsEmpty()) {
4837 xdgCacheHome = "~/.cache";
4838 }
4839 path.ReplaceSubstring("$XDG_CACHE_HOME", xdgCacheHome.get());
4841 // Expand $XDG_DATA_HOME to the environment variable, or ~/.local/share
4842 nsCString xdgDataHome(PR_GetEnv("XDG_DATA_HOME"));
4843 if (xdgDataHome.IsEmpty()) {
4844 xdgDataHome = "~/.local/share";
4845 }
4846 path.ReplaceSubstring("$XDG_DATA_HOME", xdgDataHome.get());
4850 nsresult rv =
4854 }
4859 }
4860 }
4863 // nsLocalFile::CreateAllAncestors would be nice to use
4871 }
4880 }
4881 }
4882 }
4883 }
4885 NS_IMETHODIMP
4887 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4888 // a lot of setup before they are allowed/supported and we want to pledge and
4889 // unveil early on before all of that is setup
4896 linenum++;
4898 // Cut off any comments at the end of the line, also catches lines
4899 // that are entirely a comment
4903 }
4907 }
4912 }
4917 linenum);
4918 }
4931 }
4932 }
4940 // Only unveil the pledgePath file if it's not already unveiled, otherwise
4941 // some containing directory will lose visibility.
4946 }
4949 }
4950 }
4951 }
4954 }
4957 nsAutoCString pledgeFile;
4958 nsAutoCString unveilFile;
4966 // Ensure dconf dir exists before we veil the filesystem
4971 }
5002 }
5008 }
5013 }
5017 }
5021 }
5023 // Don't overwrite an existing session dbus address, but ensure it is set
5026 }
5029 }
5030 #endif
5034 /* static */
5038 }
5040 }