| blob | dcecae0eb6d3d98db6cfe5c52a2fa18f0255432f |
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
109 #ifdef NS_PRINTING
111 #endif
141 #if defined(MOZ_SANDBOX)
143 # if defined(XP_WIN)
145 # elif defined(XP_LINUX)
149 # elif defined(XP_MACOSX)
150 # include <CoreGraphics/CGError.h>
152 # elif defined(__OpenBSD__)
153 # include <err.h>
154 # include <sys/stat.h>
155 # include <unistd.h>
157 # include <fstream>
163 # endif
164 # if defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
166 # endif
167 #endif
216 #ifdef MOZ_WEBRTC
218 #endif
224 #if defined(MOZ_WIDGET_ANDROID)
226 # include <sched.h>
227 #endif
229 #ifdef XP_WIN
230 # include <process.h>
231 # define getpid _getpid
233 #endif
235 #if defined(XP_MACOSX)
237 # include <sys/qos.h>
240 #ifdef MOZ_X11
242 #endif
244 #ifdef ACCESSIBILITY
246 # ifdef XP_WIN
248 # endif
252 #endif
257 #ifdef MOZ_WEBSPEECH
259 #endif
282 #ifdef MOZ_WIDGET_GTK
285 # include <gtk/gtk.h>
286 #endif
288 #ifdef MOZ_CODE_COVERAGE
290 #endif
312 }
318 }
325 "This is a notification of the priority change "
330 }
331 };
336 }
344 }
352 }
353 };
359 // IPC sender for remote GC/CC logging.
365 NS_DECL_ISUPPORTS
372 }
377 }
381 }
389 }
397 }
401 }
405 }
409 }
413 }
417 }
421 }
428 }
432 }
433 // The XPCOM refcount drives the IPC lifecycle;
435 }
439 "This object is a remote GC/CC logger;"
442 }
447 };
451 };
463 nsString mData;
464 };
470 NS_DECL_ISUPPORTS
471 NS_DECL_NSICONSOLELISTENER
478 };
482 // Before we send the error to the parent process (which
483 // involves copying the memory), truncate any long lines. CSS
484 // errors in particular share the memory for long lines with
485 // repeated errors, but the IPC communication we're about to do
486 // will break that sharing, so we better truncate now.
490 }
491 }
493 NS_IMETHODIMP
497 }
502 nsCString category;
529 {
530 AutoJSAPI jsapi;
539 // Because |stack| might be a cross-compartment wrapper, we can't use it
540 // with JSAutoRealm. Use the stackGlobal for that.
547 StructuredCloneData data;
548 ErrorResult err;
552 }
554 ClonedMessageData cloned;
557 }
563 }
564 }
569 }
571 nsString msg;
576 }
578 #ifdef NIGHTLY_BUILD
579 /**
580 * The singleton of this class is registered with the BackgroundHangMonitor as
581 * an annotator, so that the hang monitor can record whether or not there were
582 * pending input events when the thread hung.
583 */
590 }
591 }
594 };
596 #endif
608 // This process is a content process, so it's clearly running in
609 // multiprocess mode!
612 // Our static analysis doesn't allow capturing ref-counted pointers in
613 // lambdas, so we need to hide it in a uintptr_t. This is safe because this
614 // lambda will be destroyed in ~ContentChild().
625 aProfilingState);
626 },
627 self);
629 // When ContentChild is created, the observer service does not even exist.
630 // When ContentChild::RecvSetXPCOMProcessAttributes is called (the first
631 // IPDL call made on this object), shutdown may have already happened. Thus
632 // we create a canary here that relies upon getting cleared if shutdown
633 // happens without requiring the observer service at this time.
637 }
638 }
640 #ifdef _MSC_VER
641 # pragma warning(push)
642 # pragma warning( \
644 */
645 #endif
650 #ifndef NS_FREE_PERMANENT_DATA
652 #endif
653 }
655 #ifdef _MSC_VER
656 # pragma warning(pop)
657 #endif
662 NS_INTERFACE_MAP_END
673 }
683 aIsReadyForBackgroundProcessing);
691 }
693 }
702 }
703 };
708 #ifdef MOZ_WIDGET_GTK
709 // When running X11 only build we need to pass a display down
710 // to gtk_init because it's not going to use the one from the environment
711 // on its own when deciding which backend to use, and when starting under
712 // XWayland, it may choose to start with the wayland backend
713 // instead of the x11 backend.
714 // The DISPLAY environment variable is normally set by the parent process.
715 // The MOZ_GDK_DISPLAY environment variable is set from nsAppRunner.cpp
716 // when --display is set by the command line.
721 # ifdef MOZ_WAYLAND
723 # endif
726 }
727 }
732 // argv0 is unused because g_set_prgname() was called in
733 // XRE_InitChildProcess().
739 }
740 }
741 #endif
743 #ifdef MOZ_X11
745 // Do this after initializing GDK, or GDK will install its own handler.
747 }
748 #endif
752 // Once we start sending IPC messages, we need the thread manager to be
753 // initialized so we can deal with the responses. Do that here before we
754 // try to construct the crash reporter.
758 }
762 }
765 // If communications with the parent have broken down, take the process
766 // down so it's not hanging around.
769 // This must be checked before any IPDL message, which may hit sentinel
770 // errors due to parent and content processes having different
771 // versions.
774 // We need to quit this process if the buildID doesn't match the parent's.
775 // This can occur when an update occurred in the background.
777 }
779 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
781 #endif
783 #ifdef MOZ_X11
784 # ifdef MOZ_WIDGET_GTK
786 // Send the parent our X socket to act as a proxy reference for our X
787 // resources.
790 }
791 # endif
792 #endif
801 #ifdef NIGHTLY_BUILD
802 // NOTE: We have to register the annotator on the main thread, as annotators
803 // only affect a single thread.
808 }));
809 #endif
810 }
816 // DEFAULT_PRIVATE_BROWSING_ID is the value when it's not private
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
865 #ifdef NIGHTLY_BUILD
866 // Nightly can show site names for private windows, with a second pref
868 #endif
869 ) {
870 #if !defined(XP_MACOSX)
871 // Mac doesn't have the 15-character limit Linux does
872 // Sets profiler process name
874 nsAutoCString schemeless;
876 nsAutoCString originSuffix;
881 #endif
882 {
884 }
885 }
886 }
887 }
892 }
894 // else private window, don't change process name, or the pref isn't set
895 // mProcessName is always flat (mProcessName == aName)
902 }
913 }
918 }
923 }
926 }
936 }
941 }
949 }
955 }
959 }
963 }
978 nsresult rv;
983 // Block the attempt to open a new window if the opening BrowsingContext is
984 // not marked to use remote tabs. This ensures that the newly opened window is
985 // correctly remote.
988 }
996 }
998 // Certain conditions complicate the process of creating the new
999 // BrowsingContext, and prevent us from using the
1000 // "CreateWindowInDifferentProcess" codepath.
1001 // * With Fission enabled, process selection will happen during the load, so
1002 // switching processes eagerly will not provide a benefit.
1003 // * Windows created for printing must be created within the current process
1004 // so that a static clone of the source document can be created.
1005 // * Sandboxed popups require the full window creation codepath.
1006 // * Loads with form or POST data require the full window creation codepath.
1010 SANDBOX_PROPAGATES_TO_AUXILIARY_BROWSING_CONTEXTS) ||
1014 // If we're in a content process and we have noopener set, there's no reason
1015 // to load in our process, so let's load it elsewhere!
1028 }
1032 }
1041 // We return NS_ERROR_ABORT, so that the caller knows that we've abandoned
1042 // the window open as far as it is concerned.
1044 }
1045 }
1049 // We need to assign a TabGroup to the PBrowser actor before we send it to the
1050 // parent. Otherwise, the parent could send messages to us before we have a
1051 // proper TabGroup for that actor.
1055 }
1059 aIsPopupRequested);
1068 });
1072 // The initial about:blank document we generate within the nsDocShell will
1073 // almost certainly be replaced at some point. Unfortunately, getting the
1074 // principal right here causes bugs due to frame scripts not getting events
1075 // they expect, due to the real initial about:blank not being created yet.
1076 //
1077 // For this reason, we intentionally mispredict the initial principal here, so
1078 // that we can act the same as we did before when not predicting a result
1079 // principal. This `PWindowGlobal` will almost immediately be destroyed.
1089 }
1097 }
1099 // Open a remote endpoint for our PBrowser actor.
1103 }
1105 // Open a remote endpoint for our PWindowGlobal actor.
1110 }
1112 // Tell the parent process to set up its PBrowserParent.
1118 }
1124 }
1125 });
1127 // Now that |newChild| has had its IPC link established, call |Init| to set it
1128 // up.
1129 // XXX: This MOZ_KnownLive is only necessary because the static analysis can't
1130 // tell that NotNull<RefPtr<BrowserChild>> is a strong pointer.
1135 }
1137 // Set to true when we're ready to return from this function.
1140 // NOTE: Capturing by reference here is safe, as this function won't return
1141 // until one of these callbacks is called.
1150 // Once this function exits, we should try to exit the nested event loop.
1153 // NOTE: We have to handle this immediately in the resolve callback in order
1154 // to make sure that we don't process any more IPC messages before returning
1155 // from ProvideWindowCommon.
1157 // Handle the error which we got back from the parent process, if we got
1158 // one.
1161 }
1166 }
1168 // If the BrowserChild has been torn down, we don't need to do this anymore.
1172 }
1188 }
1190 // Unfortunately we don't get a window unless we've shown the frame. That's
1191 // pretty bogus; see bug 763602.
1201 }
1202 }
1210 }
1211 }
1214 };
1216 // NOTE: Capturing by reference here is safe, as this function won't return
1217 // until one of these callbacks is called.
1223 };
1225 // Send down the request to open the window.
1235 }
1244 // =======================
1245 // Begin Nested Event Loop
1246 // =======================
1248 // We have to wait for a response from SendCreateWindow or with information
1249 // we're going to need to return from this function, So we spin a nested event
1250 // loop until they get back to us.
1252 {
1253 // Suppress event handling for all contexts in our BrowsingContextGroup so
1254 // that event handlers cannot target our new window while it's still being
1255 // opened. Note that pending events that were suppressed while our blocker
1256 // was active will be dispatched asynchronously from a runnable dispatched
1257 // to the main event loop after this function returns, not immediately when
1258 // we leave this scope.
1261 AutoNoJSAPI nojsapi;
1263 // Spin the event loop until we get a response. Callers of this function
1264 // already have to guard against an inner event loop spinning in the
1265 // non-e10s case because of the need to spin one to create a new chrome
1266 // window.
1270 "We are on the main thread, so we should not exit this "
1272 }
1274 // =====================
1275 // End Nested Event Loop
1276 // =====================
1278 // It's possible for our new BrowsingContext to become discarded during the
1279 // nested event loop, in which case we shouldn't return it, since our callers
1280 // will generally not be prepared to deal with that.
1284 }
1286 // We should have the results already set by the callbacks.
1289 }
1297 }
1299 /* static */
1303 }
1306 }
1310 }
1318 }
1320 // Map the shared memory storing the user agent style sheets. Do this as
1321 // early as possible to maximize the chance of being able to map at the
1322 // address we want.
1324 }
1330 #ifdef MOZ_WIDGET_GTK
1331 // LookAndFeel::NativeInit takes a long time to run on Linux, here we schedule
1332 // it as soon as possible after BackgroundChild::Startup to give
1333 // it chance to run ahead of ConstructBrowser
1336 #endif
1338 #if defined(XP_WIN)
1339 // DLL services untrusted modules processing depends on
1340 // BackgroundChild::Startup having been called
1349 }
1353 // RemoteWorkerService will be initialized in RecvRemoteType, to avoid to
1354 // register it to the RemoteWorkerManager while it is still a prealloc
1355 // remoteType and defer it to the point the child process is assigned a.
1356 // actual remoteType.
1362 }
1390 }
1392 }
1399 }
1401 {
1402 AutoJSAPI jsapi;
1405 }
1406 ErrorResult rv;
1413 }
1416 }
1418 // The stylesheet cache is not ready yet. Store this URL for future use.
1424 // Initialize the RemoteDecoderManager thread and its associated PBackground
1425 // channel.
1429 kFissionEnforceBlockList);
1431 kFissionOmitBlockListValues);
1433 // Set the dynamic scalar definitions for this process.
1435 }
1442 nsCString process;
1447 }
1455 },
1456 aResolver);
1458 }
1460 #if defined(XP_WIN)
1468 },
1471 }
1477 }
1479 }
1486 }
1491 // The sink's destructor is called when the last reference goes away, which
1492 // will cause the actor to be closed down.
1497 // Invoke the dumper, which will take a reference to the sink.
1502 }
1509 }
1515 }
1517 }
1523 }
1529 }
1535 }
1540 // If we are talking to ourselves, or the UI process, then that is a fatal
1541 // protocol error.
1543 }
1545 // If we are talking to the GPU process, then we should recover from this on
1546 // the next ContentChild::RecvReinitRendering call.
1549 }
1551 #if defined(XP_MACOSX)
1554 };
1555 #endif
1565 // Note that for all of the methods below, if it can fail, it should only
1566 // return false if the failure is an IPDL error. In such situations,
1567 // ContentChild can reason about whether or not to wait for
1568 // RecvReinitRendering (because we surmised the GPU process crashed), or if it
1569 // should crash itself (because we are actually talking to the UI process). If
1570 // there are localized failures (e.g. failed to spawn a thread), then it
1571 // should MOZ_RELEASE_ASSERT or MOZ_CRASH as necessary instead.
1574 }
1577 }
1581 }
1584 }
1587 #if defined(XP_MACOSX) && !defined(MOZ_SANDBOX)
1588 // Close all current connections to the WindowServer. This ensures that the
1589 // Activity Monitor will not label the content process as "Not responding"
1590 // because it's not running a native event loop. See bug 1384336. When the
1591 // build is configured with sandbox support, this is called during sandbox
1592 // setup.
1594 #endif
1597 }
1608 // Re-establish singleton bridges to the compositor.
1611 }
1614 }
1618 }
1621 }
1624 // Establish new PLayerTransactions.
1628 }
1629 }
1631 // Notify any observers that the compositor has been reinitialized,
1632 // eg the ZoomConstraintsClients for documents in this process.
1633 // This must occur after the ReinitRendering call above so that the
1634 // APZCTreeManagers have been connected.
1639 }
1643 }
1652 }
1653 }
1655 }
1657 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
1660 };
1663 // Close all current connections to the WindowServer. This ensures that the
1664 // Activity Monitor will not label the content process as "Not responding"
1665 // because it's not running a native event loop. See bug 1384336.
1666 // This is required with or without the sandbox enabled. Until the
1667 // window server is blocked as the policy level, this should be called
1668 // just before CGSSetDenyWindowServerConnections() so there are no
1669 // windowserver connections active when CGSSetDenyWindowServerConnections()
1670 // is called.
1673 // Actual security benefits are only achieved when we additionally deny
1674 // future connections using the sandbox policy. WebGL must be remoted if
1675 // the windowserver connections are blocked. WebGL remoting is disabled
1676 // for some tests.
1683 # if !MOZ_DIAGNOSTIC_ASSERT_ENABLED
1685 # endif
1686 }
1687 }
1688 #endif
1692 // We may want to move the sandbox initialization somewhere else
1693 // at some point; see bug 880808.
1694 #if defined(MOZ_SANDBOX)
1697 # if defined(XP_LINUX)
1698 // On Linux, we have to support systems that can't use any sandboxing.
1702 // Pre-start audio before sandboxing; see bug 1443612.
1704 }
1709 }
1710 # elif defined(XP_WIN)
1712 # elif defined(XP_MACOSX)
1715 # endif
1719 # if defined(XP_LINUX) && !defined(ANDROID)
1727 }
1731 // bidi is always of type PuppetBidiKeyboard* (because in the child, the only
1732 // possible implementation of nsIBidiKeyboard is PuppetBidiKeyboard).
1737 }
1739 }
1748 }
1769 }
1770 }
1780 // Recover if the BrowsingContext is missing for a new subframe. The
1781 // `ManagedEndpoint` instances will be automatically destroyed.
1784 }
1786 // (these are the only possible values of `reason` at this point)
1787 return browsingContext
1790 }
1795 nsAutoCString idString;
1798 idString))) {
1804 }
1805 }
1806 }
1811 "Logic in CreateDocumentViewerForActor currently requires "
1813 }
1815 // We'll happily accept any kind of IPCTabContext here; we don't need to
1816 // check that it's of a certain type for security purposes, because we
1817 // believe whatever the parent process tells us.
1825 }
1831 }
1837 // Bind the created BrowserChild to IPC to actually link the actor.
1840 }
1843 windowChild))) {
1845 }
1850 }
1851 });
1853 // Ensure that a BrowsingContext is set for our BrowserChild before
1854 // running `Init`.
1861 }
1867 }
1868 // Notify parent that we are ready to handle input events.
1871 }
1876 }
1881 "Default Constructor for PRemoteSpellcheckEngineChild should never be "
1884 }
1890 }
1897 }
1904 }
1909 }
1915 }
1919 }
1924 }
1931 }
1936 }
1941 }
1949 }
1953 // Some scripts listen for "app-startup" to start. However, in the content
1954 // process, this category runs before the ScriptPreloader is initialized so
1955 // these scripts wouldn't be added to the cache. Instead, if a script needs to
1956 // run on start up in the content process, it should listen for this category.
1961 }
1970 }
1972 }
1977 }
1980 #ifdef NS_PRINTING
1982 #else
1984 #endif
1985 }
1991 }
1995 }
1999 }
2003 }
2009 }
2011 #ifdef MOZ_WEBRTC
2015 }
2020 }
2021 #endif
2033 }
2035 reset);
2037 }
2046 }
2063 }
2066 }
2075 }
2085 }
2089 }
2098 }
2107 }
2116 }
2127 }
2134 }
2141 }
2150 }
2152 }
2158 }
2163 }
2165 #ifndef NS_FREE_PERMANENT_DATA
2166 // In release builds, there's no point in the content process
2167 // going through the full XPCOM shutdown path, because it doesn't
2168 // keep persistent state.
2170 #else
2171 // Destroy our JSProcessActors, and reject any pending queries.
2174 # if defined(XP_WIN)
2182 }
2198 }
2199 }
2206 }
2224 }
2230 }
2237 }
2242 }
2247 }
2253 }
2259 }
2267 }
2276 }
2278 // aType == alertfinished, this alert is done and we can remove the
2279 // observer.
2282 });
2286 }
2289 }
2296 }
2301 }
2305 }
2307 }
2314 }
2321 }
2332 StructuredCloneData data;
2336 }
2338 }
2348 }
2351 }
2357 }
2365 }
2371 mSharedData =
2374 }
2377 }
2383 }
2391 }
2399 }
2402 }
2410 }
2413 }
2420 }
2427 }
2429 }
2435 }
2437 }
2445 }
2447 }
2453 }
2459 }
2464 }
2475 // note we do not need to force mUserContextId to the default here because
2476 // the permission manager does that internally.
2477 nsAutoCString originNoSuffix;
2478 OriginAttributes attrs;
2489 // child processes don't care about modification time.
2498 }
2510 }
2516 }
2518 }
2521 #ifdef ACCESSIBILITY
2522 // Start accessibility in content process if it's running in chrome
2523 // process.
2527 }
2530 #ifdef ACCESSIBILITY
2531 // Try to shutdown accessibility in content process if it's shutting down in
2532 // chrome process.
2534 #endif
2536 }
2539 // Rebroadcast the "application-foreground"
2543 }
2545 }
2548 // Rebroadcast the "application-background"
2552 }
2554 }
2557 // Rebroadcast the "child-gc-request" so that workers will GC.
2561 }
2564 }
2567 // Rebroadcast the "child-cc-request" so that workers will CC.
2571 }
2574 }
2577 #ifdef DEBUG
2579 #endif
2581 }
2597 }
2602 // Allocation of preallocated processes that are still launching can
2603 // cause this
2605 }
2608 // Preallocated processes are type PREALLOC_REMOTE_TYPE; they may not
2609 // become a File: process, or Privileged About Content Process
2613 // prealloc->anything (but file) or web->web allowed, and no-change
2618 // Initial setting of remote type. Either to 'prealloc' or the actual
2619 // final type (if we didn't use a preallocated process)
2626 }
2627 }
2631 // Must do before SetProcessName
2634 // Update the process name so about:memory's process names are more obvious.
2644 // The profiler can sanitize out the eTLD+1
2645 nsDependentCSubstring etld =
2647 #ifdef NIGHTLY_BUILD
2649 #else
2652 #endif
2654 // The profiler can sanitize out the eTLD+1
2655 nsDependentCSubstring etld =
2659 // The profiler can sanitize out the eTLD+1
2660 nsDependentCSubstring etld =
2664 // else "prealloc" or "web" type -> "Web Content"
2666 }
2668 // Turn off Spectre mitigations in isolated web content processes.
2676 }
2678 // Use the prefix to avoid URIs from Fission isolated processes.
2682 // Defer RemoteWorkerService initialization until the child process does
2683 // receive its specific remoteType and can become actionable for the
2684 // RemoteWorkerManager in the parent process.
2687 }
2690 }
2692 // A method to initialize anything we need during the preallocation phase
2696 // SetAcceptLanguages() needs to read localized strings (file access),
2697 // which is slow, so do this in prealloc
2699 }
2701 // Call RemoteTypePrefix() on the result to remove URIs if you want to use this
2702 // for telemetry.
2715 // If we have received an already-revoked blobURL, we have to keep it alive
2716 // for a while (see BlobURLProtocolHandler) in order to support pending
2717 // operations such as navigation, download and so on.
2720 }
2721 }
2724 }
2732 }
2739 }
2746 }
2752 }
2769 // Record FOG data before the priority change.
2770 // Ignore the change if it's the first time we set the process priority.
2773 }
2784 // Note: keep this in sync with the JS shell (js/src/shell/js.cpp).
2790 }
2791 }
2794 }
2803 }
2808 // Make sure aObserver isn't released while we wait for the parent
2812 }
2820 }
2830 }
2832 }
2838 }
2843 }
2846 }
2852 }
2857 }
2860 }
2867 }
2873 }
2875 }
2878 "If the domain policy is not active yet,"
2881 }
2889 }
2908 }
2927 }
2930 }
2935 }
2944 }
2945 }
2947 /* static */
2950 }
2956 // Bug 1755376: If we see "RecvShutdownConfirmedHP entry" often in
2957 // bug IPCError_ShutDownKill we might want to anticipate
2958 // ShutdownPhase::AppShutdownConfirmed to start here.
2961 }
2966 // Signal the ongoing shutdown to AppShutdown, this
2967 // will make abort nested SpinEventLoopUntilOrQuit loops
2978 }
2982 }
2987 // If we receive the shutdown message from within a nested event loop, we want
2988 // to wait for that event loop to finish. Otherwise we could prematurely
2989 // terminate an "unload" or "pagehide" event handler (which might be doing a
2990 // sync XHR, for example).
2994 // Note that we only have to check the recursion count for the current
2995 // cooperative thread. Since the Shutdown message is not labeled with a
2996 // SchedulerGroup, there can be no other cooperative threads doing work while
2997 // we're running.
2999 // We're in a nested event loop. Let's delay for an arbitrary period of
3000 // time (100ms) in the hopes that the event loop will have finished by
3001 // then.
3007 }
3011 #ifdef NIGHTLY_BUILD
3014 #endif
3019 }
3026 }
3036 ProfileAndAdditionalInformation shutdownProfileAndAdditionalInformation =
3053 }
3054 // Send the shutdown profile to the parent process through our own
3055 // message channel, which we know will survive for long enough.
3064 }
3068 }
3070 // Start a timer that will ensure we quickly exit after a reasonable period
3071 // of time. Prevents shutdown hangs after our connection to the parent
3072 // closes or when the parent is too busy to ever kill us.
3079 // Notify the parent that we are done with shutdown. This is sent with high
3080 // priority and will just flag we are done.
3083 // Now tell the parent to actually destroy our channel which will make end
3084 // our process. This is expected to be the last event the parent will
3085 // ever process for this ContentChild.
3090 }
3098 }
3100 PContentPermissionRequestChild*
3107 }
3115 }
3121 }
3128 }
3133 }
3141 }
3143 }
3147 // Check if we are receiving any file objects. If we are we will want
3148 // to hide any of the other objects coming in from content.
3156 }
3157 }
3158 }
3159 // Add the entries from the IPC to the new DataTransfer
3167 nsresult rv =
3171 }
3173 // We should hide this data from content if we have a file, and we
3174 // aren't a file.
3181 }
3182 }
3184 }
3204 }
3205 }
3207 }
3211 EventMessage aEventMessage) {
3220 }
3221 }
3223 }
3236 }
3241 }
3242 }
3247 }
3249 }
3257 }
3266 }
3273 }
3282 }
3290 }
3299 blobImpl);
3301 }
3306 aURI,
3309 }
3319 }
3328 }
3334 // This object can already been deleted in case DeleteGetFilesRequest has
3335 // been called when the response was sending by the parent.
3338 }
3353 }
3356 }
3358 }
3360 /* static */
3363 // If we're communicating with the same process or the UI process then we
3364 // want to crash normally. Otherwise we want to just warn as the other end
3365 // must be the GPU process and it crashing shouldn't be fatal for us.
3373 NS_WARNING(formattedMessage.get());
3374 }
3375 }
3377 PURLClassifierChild* ContentChild::AllocPURLClassifierChild(
3378 nsIPrincipal* aPrincipal, bool* aSuccess) {
3379 *aSuccess = true;
3380 return new URLClassifierChild();
3381 }
3383 bool ContentChild::DeallocPURLClassifierChild(PURLClassifierChild* aActor) {
3384 MOZ_ASSERT(aActor);
3385 delete aActor;
3386 return true;
3387 }
3389 PURLClassifierLocalChild* ContentChild::AllocPURLClassifierLocalChild(
3390 nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures) {
3391 return new URLClassifierLocalChild();
3392 }
3394 bool ContentChild::DeallocPURLClassifierLocalChild(
3395 PURLClassifierLocalChild* aActor) {
3396 MOZ_ASSERT(aActor);
3397 delete aActor;
3398 return true;
3399 }
3401 PSessionStorageObserverChild*
3402 ContentChild::AllocPSessionStorageObserverChild() {
3403 MOZ_CRASH(
3405 }
3407 bool ContentChild::DeallocPSessionStorageObserverChild(
3408 PSessionStorageObserverChild* aActor) {
3409 MOZ_ASSERT(aActor);
3411 delete aActor;
3412 return true;
3413 }
3415 mozilla::ipc::IPCResult ContentChild::RecvProvideAnonymousTemporaryFile(
3416 const uint64_t& aID, const FileDescOrError& aFDOrError) {
3417 mozilla::UniquePtr<AnonymousTemporaryFileCallback> callback;
3418 mPendingAnonymousTemporaryFiles.Remove(aID, &callback);
3419 MOZ_ASSERT(callback);
3421 PRFileDesc* prfile = nullptr;
3422 if (aFDOrError.type() == FileDescOrError::Tnsresult) {
3423 DebugOnly<nsresult> rv = aFDOrError.get_nsresult();
3424 MOZ_ASSERT(NS_FAILED(rv));
3425 } else {
3426 auto rawFD = aFDOrError.get_FileDescriptor().ClonePlatformHandle();
3427 prfile = PR_ImportFile(PROsfd(rawFD.release()));
3428 }
3429 (*callback)(prfile);
3430 return IPC_OK();
3431 }
3433 nsresult ContentChild::AsyncOpenAnonymousTemporaryFile(
3434 const AnonymousTemporaryFileCallback& aCallback) {
3435 MOZ_ASSERT(NS_IsMainThread());
3437 static uint64_t id = 0;
3438 auto newID = id++;
3439 if (!SendRequestAnonymousTemporaryFile(newID)) {
3440 return NS_ERROR_FAILURE;
3441 }
3443 // Remember the association with the callback.
3444 MOZ_ASSERT(!mPendingAnonymousTemporaryFiles.Get(newID));
3445 mPendingAnonymousTemporaryFiles.GetOrInsertNew(newID, aCallback);
3446 return NS_OK;
3447 }
3449 mozilla::ipc::IPCResult ContentChild::RecvSetPermissionsWithKey(
3450 const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms) {
3451 RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
3452 if (permManager) {
3453 permManager->SetPermissionsWithKey(aPermissionKey, aPerms);
3454 }
3456 return IPC_OK();
3457 }
3459 mozilla::ipc::IPCResult ContentChild::RecvRefreshScreens(
3460 nsTArray<ScreenDetails>&& aScreens) {
3461 ScreenManager& screenManager = ScreenManager::GetSingleton();
3462 screenManager.Refresh(std::move(aScreens));
3463 return IPC_OK();
3464 }
3466 mozilla::ipc::IPCResult ContentChild::RecvShareCodeCoverageMutex(
3467 CrossProcessMutexHandle aHandle) {
3468 #ifdef MOZ_CODE_COVERAGE
3469 CodeCoverageHandler::Init(std::move(aHandle));
3470 return IPC_OK();
3471 #else
3473 #endif
3474 }
3476 mozilla::ipc::IPCResult ContentChild::RecvFlushCodeCoverageCounters(
3477 FlushCodeCoverageCountersResolver&& aResolver) {
3478 #ifdef MOZ_CODE_COVERAGE
3479 CodeCoverageHandler::FlushCounters();
3480 aResolver(/* unused */ true);
3481 return IPC_OK();
3482 #else
3484 #endif
3485 }
3487 mozilla::ipc::IPCResult ContentChild::RecvSetInputEventQueueEnabled() {
3488 nsThreadManager::get().EnableMainThreadEventPrioritization();
3489 return IPC_OK();
3490 }
3492 mozilla::ipc::IPCResult ContentChild::RecvFlushInputEventQueue() {
3493 nsThreadManager::get().FlushInputEventPrioritization();
3494 return IPC_OK();
3495 }
3497 mozilla::ipc::IPCResult ContentChild::RecvSuspendInputEventQueue() {
3498 nsThreadManager::get().SuspendInputEventPrioritization();
3499 return IPC_OK();
3500 }
3502 mozilla::ipc::IPCResult ContentChild::RecvResumeInputEventQueue() {
3503 nsThreadManager::get().ResumeInputEventPrioritization();
3504 return IPC_OK();
3505 }
3507 mozilla::ipc::IPCResult ContentChild::RecvAddDynamicScalars(
3508 nsTArray<DynamicScalarDefinition>&& aDefs) {
3509 TelemetryIPC::AddDynamicScalarDefinitions(aDefs);
3510 return IPC_OK();
3511 }
3513 mozilla::ipc::IPCResult ContentChild::RecvCrossProcessRedirect(
3514 RedirectToRealChannelArgs&& aArgs,
3515 nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
3516 CrossProcessRedirectResolver&& aResolve) {
3517 nsCOMPtr<nsILoadInfo> loadInfo;
3518 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
3519 aArgs.loadInfo(), NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
3520 if (NS_FAILED(rv)) {
3522 return IPC_OK();
3523 }
3525 nsCOMPtr<nsIChannel> newChannel;
3526 MOZ_ASSERT((aArgs.loadStateInternalLoadFlags() &
3527 nsDocShell::InternalLoad::INTERNAL_LOAD_FLAGS_IS_SRCDOC) ||
3528 aArgs.srcdocData().IsVoid());
3529 rv = nsDocShell::CreateRealChannelForDocument(
3530 getter_AddRefs(newChannel), aArgs.uri(), loadInfo, nullptr,
3531 aArgs.newLoadFlags(), aArgs.srcdocData(), aArgs.baseUri());
3533 if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
3534 httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
3535 httpChannel->SetEarlyHintLinkType(aArgs.earlyHintLinkType());
3536 }
3538 // This is used to report any errors back to the parent by calling
3539 // CrossProcessRedirectFinished.
3540 RefPtr<HttpChannelChild> httpChild = do_QueryObject(newChannel);
3541 auto resolve = [=](const nsresult& aRv) {
3542 nsresult rv = aRv;
3543 if (httpChild) {
3544 rv = httpChild->CrossProcessRedirectFinished(rv);
3545 }
3546 aResolve(rv);
3547 };
3548 auto scopeExit = MakeScopeExit([&]() { resolve(rv); });
3550 if (NS_FAILED(rv)) {
3551 return IPC_OK();
3552 }
3554 if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel)) {
3555 rv = httpChannel->SetChannelId(aArgs.channelId());
3556 }
3557 if (NS_FAILED(rv)) {
3558 return IPC_OK();
3559 }
3561 rv = newChannel->SetOriginalURI(aArgs.originalURI());
3562 if (NS_FAILED(rv)) {
3563 return IPC_OK();
3564 }
3566 if (nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
3567 do_QueryInterface(newChannel)) {
3568 rv = httpChannelInternal->SetRedirectMode(aArgs.redirectMode());
3569 }
3570 if (NS_FAILED(rv)) {
3571 return IPC_OK();
3572 }
3574 if (aArgs.init()) {
3575 HttpBaseChannel::ReplacementChannelConfig config(std::move(*aArgs.init()));
3576 HttpBaseChannel::ConfigureReplacementChannel(
3577 newChannel, config,
3578 HttpBaseChannel::ReplacementReason::DocumentChannel);
3579 }
3581 if (aArgs.contentDisposition()) {
3582 newChannel->SetContentDisposition(*aArgs.contentDisposition());
3583 }
3585 if (aArgs.contentDispositionFilename()) {
3586 newChannel->SetContentDispositionFilename(
3587 *aArgs.contentDispositionFilename());
3588 }
3590 if (nsCOMPtr<nsIChildChannel> childChannel = do_QueryInterface(newChannel)) {
3591 // Connect to the parent if this is a remote channel. If it's entirely
3592 // handled locally, then we'll call AsyncOpen from the docshell when
3593 // we complete the setup
3594 rv = childChannel->ConnectParent(
3595 aArgs.registrarId()); // creates parent channel
3596 if (NS_FAILED(rv)) {
3597 return IPC_OK();
3598 }
3599 }
3601 // We need to copy the property bag before signaling that the channel
3602 // is ready so that the nsDocShell can retrieve the history data when called.
3603 if (nsCOMPtr<nsIWritablePropertyBag> bag = do_QueryInterface(newChannel)) {
3604 nsHashPropertyBag::CopyFrom(bag, aArgs.properties());
3605 }
3607 RefPtr<nsDocShellLoadState> loadState;
3608 rv = nsDocShellLoadState::CreateFromPendingChannel(
3609 newChannel, aArgs.loadIdentifier(), aArgs.registrarId(),
3610 getter_AddRefs(loadState));
3611 if (NS_WARN_IF(NS_FAILED(rv))) {
3612 return IPC_OK();
3613 }
3614 loadState->SetLoadFlags(aArgs.loadStateExternalLoadFlags());
3615 loadState->SetInternalLoadFlags(aArgs.loadStateInternalLoadFlags());
3616 if (IsValidLoadType(aArgs.loadStateLoadType())) {
3617 loadState->SetLoadType(aArgs.loadStateLoadType());
3618 }
3620 if (aArgs.loadingSessionHistoryInfo().isSome()) {
3621 loadState->SetLoadingSessionHistoryInfo(
3622 aArgs.loadingSessionHistoryInfo().ref());
3623 }
3624 if (aArgs.originalUriString().isSome()) {
3625 loadState->SetOriginalURIString(aArgs.originalUriString().ref());
3626 }
3628 RefPtr<ChildProcessChannelListener> processListener =
3629 ChildProcessChannelListener::GetSingleton();
3630 // The listener will call completeRedirectSetup or asyncOpen on the channel.
3631 processListener->OnChannelReady(loadState, aArgs.loadIdentifier(),
3632 std::move(aEndpoints), aArgs.timing(),
3633 std::move(resolve));
3634 scopeExit.release();
3636 // scopeExit will call CrossProcessRedirectFinished(rv) here
3637 return IPC_OK();
3638 }
3640 mozilla::ipc::IPCResult ContentChild::RecvStartDelayedAutoplayMediaComponents(
3641 const MaybeDiscarded<BrowsingContext>& aContext) {
3642 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3643 return IPC_OK();
3644 }
3646 aContext.get()->StartDelayedAutoplayMediaComponents();
3647 return IPC_OK();
3648 }
3650 mozilla::ipc::IPCResult ContentChild::RecvUpdateMediaControlAction(
3651 const MaybeDiscarded<BrowsingContext>& aContext,
3652 const MediaControlAction& aAction) {
3653 if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
3654 return IPC_OK();
3655 }
3657 ContentMediaControlKeyHandler::HandleMediaControlAction(aContext.get(),
3658 aAction);
3659 return IPC_OK();
3660 }
3662 mozilla::ipc::IPCResult ContentChild::RecvOnAllowAccessFor(
3663 const MaybeDiscarded<BrowsingContext>& aContext,
3664 const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
3665 const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
3666 aReason) {
3669 StorageAccessAPIHelper::OnAllowAccessFor(
3670 aContext.GetMaybeDiscarded(), aTrackingOrigin, aCookieBehavior, aReason);
3672 return IPC_OK();
3673 }
3675 mozilla::ipc::IPCResult ContentChild::RecvOnContentBlockingDecision(
3676 const MaybeDiscarded<BrowsingContext>& aContext,
3677 const ContentBlockingNotifier::BlockingDecision& aDecision,
3678 uint32_t aRejectedReason) {
3681 nsCOMPtr<nsPIDOMWindowOuter> outer = aContext.get()->GetDOMWindow();
3682 if (!outer) {
3683 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3686 return IPC_OK();
3687 }
3689 nsCOMPtr<nsPIDOMWindowInner> inner = outer->GetCurrentInnerWindow();
3690 if (!inner) {
3691 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3694 return IPC_OK();
3695 }
3697 ContentBlockingNotifier::OnDecision(inner, aDecision, aRejectedReason);
3698 return IPC_OK();
3699 }
3701 #ifdef NIGHTLY_BUILD
3702 void ContentChild::OnChannelReceivedMessage(const Message& aMsg) {
3703 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3704 mPendingInputEvents++;
3705 }
3706 }
3708 PContentChild::Result ContentChild::OnMessageReceived(const Message& aMsg) {
3709 if (nsContentUtils::IsMessageInputEvent(aMsg)) {
3710 DebugOnly<uint32_t> prevEvts = mPendingInputEvents--;
3711 MOZ_ASSERT(prevEvts > 0);
3712 }
3714 return PContentChild::OnMessageReceived(aMsg);
3715 }
3717 PContentChild::Result ContentChild::OnMessageReceived(
3718 const Message& aMsg, UniquePtr<Message>& aReply) {
3719 return PContentChild::OnMessageReceived(aMsg, aReply);
3720 }
3721 #endif
3723 mozilla::ipc::IPCResult ContentChild::RecvCreateBrowsingContext(
3724 uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit) {
3725 // We can't already have a BrowsingContext with this ID.
3726 if (RefPtr<BrowsingContext> existing = BrowsingContext::Get(aInit.mId)) {
3728 }
3730 RefPtr<WindowContext> parent = WindowContext::GetById(aInit.mParentId);
3731 if (!parent && aInit.mParentId != 0) {
3732 // Handle this case by ignoring the request, as parent must be in the
3733 // process of being discarded.
3734 // In the future it would be nice to avoid sending this message to the child
3735 // at all.
3737 return IPC_OK();
3738 }
3740 RefPtr<BrowsingContextGroup> group =
3741 BrowsingContextGroup::GetOrCreate(aGroupId);
3742 return BrowsingContext::CreateFromIPC(std::move(aInit), group, nullptr);
3743 }
3745 mozilla::ipc::IPCResult ContentChild::RecvDiscardBrowsingContext(
3746 const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
3747 DiscardBrowsingContextResolver&& aResolve) {
3748 if (BrowsingContext* context = aContext.GetMaybeDiscarded()) {
3749 if (aDoDiscard && !context->IsDiscarded()) {
3750 context->Detach(/* aFromIPC */ true);
3751 }
3752 context->AddDiscardListener(aResolve);
3753 return IPC_OK();
3754 }
3756 // Immediately resolve the promise, as we've received the message. This will
3757 // allow the parent process to discard references to this BC.
3758 aResolve(true);
3759 return IPC_OK();
3760 }
3762 mozilla::ipc::IPCResult ContentChild::RecvRegisterBrowsingContextGroup(
3763 uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits) {
3764 RefPtr<BrowsingContextGroup> group =
3765 BrowsingContextGroup::GetOrCreate(aGroupId);
3767 // Each of the initializers in aInits is sorted in pre-order, so our parent
3768 // should always be available before the element itself.
3769 for (auto& initUnion : aInits) {
3770 switch (initUnion.type()) {
3771 case SyncedContextInitializer::TBrowsingContextInitializer: {
3772 auto& init = initUnion.get_BrowsingContextInitializer();
3773 #ifdef DEBUG
3774 RefPtr<BrowsingContext> existing = BrowsingContext::Get(init.mId);
3777 RefPtr<WindowContext> parent = init.GetParent();
3778 MOZ_ASSERT_IF(parent, parent->Group() == group);
3779 #endif
3781 BrowsingContext::CreateFromIPC(std::move(init), group, nullptr);
3782 break;
3783 }
3784 case SyncedContextInitializer::TWindowContextInitializer: {
3785 auto& init = initUnion.get_WindowContextInitializer();
3786 #ifdef DEBUG
3787 RefPtr<WindowContext> existing =
3788 WindowContext::GetById(init.mInnerWindowId);
3790 RefPtr<BrowsingContext> parent =
3791 BrowsingContext::Get(init.mBrowsingContextId);
3792 MOZ_ASSERT(parent && parent->Group() == group);
3793 #endif
3795 WindowContext::CreateFromIPC(std::move(init));
3796 break;
3797 };
3798 default:
3799 MOZ_ASSERT_UNREACHABLE();
3800 }
3801 }
3803 return IPC_OK();
3804 }
3806 mozilla::ipc::IPCResult ContentChild::RecvDestroyBrowsingContextGroup(
3807 uint64_t aGroupId) {
3808 if (RefPtr<BrowsingContextGroup> group =
3809 BrowsingContextGroup::GetExisting(aGroupId)) {
3810 group->ChildDestroy();
3811 }
3812 return IPC_OK();
3813 }
3815 mozilla::ipc::IPCResult ContentChild::RecvWindowClose(
3816 const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller) {
3817 if (aContext.IsNullOrDiscarded()) {
3818 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3820 return IPC_OK();
3821 }
3823 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3824 if (!window) {
3825 MOZ_LOG(
3826 BrowsingContext::GetLog(), LogLevel::Debug,
3828 return IPC_OK();
3829 }
3831 // Call `GetDocument()` to force the document and its inner window to be
3832 // created, as it would be forced to be created if this call was being
3833 // performed in-process.
3834 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3835 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3838 return IPC_OK();
3839 }
3841 nsGlobalWindowOuter::Cast(window)->CloseOuter(aTrustedCaller);
3842 return IPC_OK();
3843 }
3845 mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(
3846 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3847 uint64_t aActionId) {
3848 if (aContext.IsNullOrDiscarded()) {
3849 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3851 return IPC_OK();
3852 }
3854 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3855 if (!window) {
3856 MOZ_LOG(
3857 BrowsingContext::GetLog(), LogLevel::Debug,
3859 return IPC_OK();
3860 }
3862 // Call `GetDocument()` to force the document and its inner window to be
3863 // created, as it would be forced to be created if this call was being
3864 // performed in-process.
3865 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3866 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3869 return IPC_OK();
3870 }
3872 nsGlobalWindowOuter::Cast(window)->FocusOuter(
3873 aCallerType, /* aFromOtherProcess */ true, aActionId);
3874 return IPC_OK();
3875 }
3877 mozilla::ipc::IPCResult ContentChild::RecvWindowBlur(
3878 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType) {
3879 if (aContext.IsNullOrDiscarded()) {
3880 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3882 return IPC_OK();
3883 }
3885 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3886 if (!window) {
3887 MOZ_LOG(
3888 BrowsingContext::GetLog(), LogLevel::Debug,
3890 return IPC_OK();
3891 }
3893 // Call `GetDocument()` to force the document and its inner window to be
3894 // created, as it would be forced to be created if this call was being
3895 // performed in-process.
3896 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
3897 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3900 return IPC_OK();
3901 }
3903 nsGlobalWindowOuter::Cast(window)->BlurOuter(aCallerType);
3904 return IPC_OK();
3905 }
3907 mozilla::ipc::IPCResult ContentChild::RecvRaiseWindow(
3908 const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
3909 uint64_t aActionId) {
3910 if (aContext.IsNullOrDiscarded()) {
3911 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3913 return IPC_OK();
3914 }
3916 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3917 if (!window) {
3918 MOZ_LOG(
3919 BrowsingContext::GetLog(), LogLevel::Debug,
3921 return IPC_OK();
3922 }
3924 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3925 fm->RaiseWindow(window, aCallerType, aActionId);
3926 }
3927 return IPC_OK();
3928 }
3930 mozilla::ipc::IPCResult ContentChild::RecvAdjustWindowFocus(
3931 const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
3932 uint64_t aActionId) {
3933 if (aContext.IsNullOrDiscarded()) {
3934 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3936 return IPC_OK();
3937 }
3939 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3940 RefPtr<BrowsingContext> bc = aContext.get();
3941 fm->AdjustInProcessWindowFocus(bc, false, aIsVisible, aActionId);
3942 }
3943 return IPC_OK();
3944 }
3946 mozilla::ipc::IPCResult ContentChild::RecvClearFocus(
3947 const MaybeDiscarded<BrowsingContext>& aContext) {
3948 if (aContext.IsNullOrDiscarded()) {
3949 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3951 return IPC_OK();
3952 }
3954 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
3955 if (!window) {
3956 MOZ_LOG(
3957 BrowsingContext::GetLog(), LogLevel::Debug,
3959 return IPC_OK();
3960 }
3962 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3963 fm->ClearFocus(window);
3964 }
3965 return IPC_OK();
3966 }
3968 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedBrowsingContext(
3969 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3970 if (aContext.IsNullOrDiscarded()) {
3971 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3973 return IPC_OK();
3974 }
3976 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3977 if (fm) {
3978 fm->SetFocusedBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3979 }
3980 return IPC_OK();
3981 }
3983 mozilla::ipc::IPCResult ContentChild::RecvSetActiveBrowsingContext(
3984 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
3985 if (aContext.IsNullOrDiscarded()) {
3986 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
3988 return IPC_OK();
3989 }
3991 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3992 if (fm) {
3993 fm->SetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
3994 }
3995 return IPC_OK();
3996 }
3998 mozilla::ipc::IPCResult ContentChild::RecvAbortOrientationPendingPromises(
3999 const MaybeDiscarded<BrowsingContext>& aContext) {
4000 if (aContext.IsNullOrDiscarded()) {
4001 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4003 return IPC_OK();
4004 }
4006 dom::ScreenOrientation::AbortInProcessOrientationPromises(aContext.get());
4007 return IPC_OK();
4008 }
4010 mozilla::ipc::IPCResult ContentChild::RecvUnsetActiveBrowsingContext(
4011 const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
4012 if (aContext.IsNullOrDiscarded()) {
4013 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4015 return IPC_OK();
4016 }
4018 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4019 if (fm) {
4020 fm->UnsetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
4021 }
4022 return IPC_OK();
4023 }
4025 mozilla::ipc::IPCResult ContentChild::RecvSetFocusedElement(
4026 const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus) {
4027 if (aContext.IsNullOrDiscarded()) {
4028 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4030 return IPC_OK();
4031 }
4033 nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
4034 if (!window) {
4035 MOZ_LOG(
4036 BrowsingContext::GetLog(), LogLevel::Debug,
4038 return IPC_OK();
4039 }
4041 window->SetFocusedElement(nullptr, 0, aNeedsFocus);
4042 return IPC_OK();
4043 }
4045 mozilla::ipc::IPCResult ContentChild::RecvFinalizeFocusOuter(
4046 const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
4047 CallerType aCallerType) {
4048 if (aContext.IsNullOrDiscarded()) {
4049 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4051 return IPC_OK();
4052 }
4054 if (Element* frame = aContext.get()->GetEmbedderElement()) {
4055 nsContentUtils::RequestFrameFocus(*frame, aCanFocus, aCallerType);
4056 }
4058 return IPC_OK();
4059 }
4061 mozilla::ipc::IPCResult ContentChild::RecvBlurToChild(
4062 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4063 const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
4064 const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
4065 bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId) {
4066 if (aFocusedBrowsingContext.IsNullOrDiscarded()) {
4067 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4069 return IPC_OK();
4070 }
4072 RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
4073 if (MOZ_UNLIKELY(!fm)) {
4074 return IPC_OK();
4075 }
4077 RefPtr<BrowsingContext> toClear = aBrowsingContextToClear.IsDiscarded()
4078 ? nullptr
4079 : aBrowsingContextToClear.get();
4080 RefPtr<BrowsingContext> toFocus =
4081 aAncestorBrowsingContextToFocus.IsDiscarded()
4082 ? nullptr
4083 : aAncestorBrowsingContextToFocus.get();
4085 RefPtr<BrowsingContext> focusedBrowsingContext =
4086 aFocusedBrowsingContext.get();
4088 fm->BlurFromOtherProcess(focusedBrowsingContext, toClear, toFocus,
4089 aIsLeavingDocument, aAdjustWidget, aActionId);
4090 return IPC_OK();
4091 }
4093 mozilla::ipc::IPCResult ContentChild::RecvSetupFocusedAndActive(
4094 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4095 uint64_t aActionIdForFocused,
4096 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4097 uint64_t aActionIdForActive) {
4098 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4099 if (fm) {
4100 if (!aActiveBrowsingContext.IsNullOrDiscarded()) {
4101 fm->SetActiveBrowsingContextFromOtherProcess(aActiveBrowsingContext.get(),
4102 aActionIdForActive);
4103 }
4104 if (!aFocusedBrowsingContext.IsNullOrDiscarded()) {
4105 fm->SetFocusedBrowsingContextFromOtherProcess(
4106 aFocusedBrowsingContext.get(), aActionIdForFocused);
4107 }
4108 }
4109 return IPC_OK();
4110 }
4112 mozilla::ipc::IPCResult ContentChild::RecvReviseActiveBrowsingContext(
4113 uint64_t aOldActionId,
4114 const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
4115 uint64_t aNewActionId) {
4116 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4117 if (fm && !aActiveBrowsingContext.IsNullOrDiscarded()) {
4118 fm->ReviseActiveBrowsingContext(aOldActionId, aActiveBrowsingContext.get(),
4119 aNewActionId);
4120 }
4121 return IPC_OK();
4122 }
4124 mozilla::ipc::IPCResult ContentChild::RecvReviseFocusedBrowsingContext(
4125 uint64_t aOldActionId,
4126 const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
4127 uint64_t aNewActionId) {
4128 nsFocusManager* fm = nsFocusManager::GetFocusManager();
4129 if (fm && !aFocusedBrowsingContext.IsNullOrDiscarded()) {
4130 fm->ReviseFocusedBrowsingContext(
4131 aOldActionId, aFocusedBrowsingContext.get(), aNewActionId);
4132 }
4133 return IPC_OK();
4134 }
4136 mozilla::ipc::IPCResult ContentChild::RecvMaybeExitFullscreen(
4137 const MaybeDiscarded<BrowsingContext>& aContext) {
4138 if (aContext.IsNullOrDiscarded()) {
4139 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4141 return IPC_OK();
4142 }
4144 nsIDocShell* shell = aContext.get()->GetDocShell();
4145 if (!shell) {
4146 return IPC_OK();
4147 }
4149 Document* doc = shell->GetDocument();
4150 if (doc && doc->GetFullscreenElement()) {
4151 Document::AsyncExitFullscreen(doc);
4152 }
4154 return IPC_OK();
4155 }
4157 mozilla::ipc::IPCResult ContentChild::RecvWindowPostMessage(
4158 const MaybeDiscarded<BrowsingContext>& aContext,
4159 const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData) {
4160 if (aContext.IsNullOrDiscarded()) {
4161 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4163 return IPC_OK();
4164 }
4166 RefPtr<nsGlobalWindowOuter> window =
4167 nsGlobalWindowOuter::Cast(aContext.get()->GetDOMWindow());
4168 if (!window) {
4169 MOZ_LOG(
4170 BrowsingContext::GetLog(), LogLevel::Debug,
4172 return IPC_OK();
4173 }
4175 nsCOMPtr<nsIPrincipal> providedPrincipal;
4176 if (!window->GetPrincipalForPostMessage(
4177 aData.targetOrigin(), aData.targetOriginURI(),
4178 aData.callerPrincipal(), *aData.subjectPrincipal(),
4179 getter_AddRefs(providedPrincipal))) {
4180 return IPC_OK();
4181 }
4183 // Call `GetDocument()` to force the document and its inner window to be
4184 // created, as it would be forced to be created if this call was being
4185 // performed in-process.
4186 if (NS_WARN_IF(!aContext.get()->GetDocument())) {
4187 MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
4190 return IPC_OK();
4191 }
4193 // It's OK if `sourceBc` has already been discarded, so long as we can
4194 // continue to wrap it.
4195 RefPtr<BrowsingContext> sourceBc = aData.source().GetMaybeDiscarded();
4197 // Create and asynchronously dispatch a runnable which will handle actual DOM
4198 // event creation and dispatch.
4199 RefPtr<PostMessageEvent> event =
4200 new PostMessageEvent(sourceBc, aData.origin(), window, providedPrincipal,
4201 aData.innerWindowId(), aData.callerURI(),
4202 aData.scriptLocation(), aData.isFromPrivateWindow());
4203 event->UnpackFrom(aMessage);
4205 event->DispatchToTargetThread(IgnoredErrorResult());
4206 return IPC_OK();
4207 }
4209 mozilla::ipc::IPCResult ContentChild::RecvCommitBrowsingContextTransaction(
4210 const MaybeDiscarded<BrowsingContext>& aContext,
4211 BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4212 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4213 }
4215 mozilla::ipc::IPCResult ContentChild::RecvCommitWindowContextTransaction(
4216 const MaybeDiscarded<WindowContext>& aContext,
4217 WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
4218 return aTransaction.CommitFromIPC(aContext, aEpoch, this);
4219 }
4221 mozilla::ipc::IPCResult ContentChild::RecvCreateWindowContext(
4222 WindowContext::IPCInitializer&& aInit) {
4223 RefPtr<BrowsingContext> bc = BrowsingContext::Get(aInit.mBrowsingContextId);
4224 if (!bc) {
4225 // Handle this case by ignoring the request, as bc must be in the process of
4226 // being discarded.
4227 // In the future it would be nice to avoid sending this message to the child
4228 // at all.
4230 return IPC_OK();
4231 }
4233 WindowContext::CreateFromIPC(std::move(aInit));
4234 return IPC_OK();
4235 }
4237 mozilla::ipc::IPCResult ContentChild::RecvDiscardWindowContext(
4238 uint64_t aContextId, DiscardWindowContextResolver&& aResolve) {
4239 // Resolve immediately to acknowledge call
4240 aResolve(true);
4242 RefPtr<WindowContext> window = WindowContext::GetById(aContextId);
4243 if (NS_WARN_IF(!window) || NS_WARN_IF(window->IsDiscarded())) {
4244 return IPC_OK();
4245 }
4247 window->Discard();
4248 return IPC_OK();
4249 }
4251 mozilla::ipc::IPCResult ContentChild::RecvScriptError(
4252 const nsString& aMessage, const nsString& aSourceName,
4253 const nsString& aSourceLine, const uint32_t& aLineNumber,
4254 const uint32_t& aColNumber, const uint32_t& aFlags,
4255 const nsCString& aCategory, const bool& aFromPrivateWindow,
4256 const uint64_t& aInnerWindowId, const bool& aFromChromeContext) {
4257 nsresult rv = NS_OK;
4258 nsCOMPtr<nsIConsoleService> consoleService =
4259 do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
4262 nsCOMPtr<nsIScriptError> scriptError(
4263 do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
4264 NS_ENSURE_TRUE(scriptError,
4267 scriptError->InitWithWindowID(aMessage, aSourceName, aSourceLine, aLineNumber,
4268 aColNumber, aFlags, aCategory, aInnerWindowId,
4269 aFromChromeContext);
4270 rv = consoleService->LogMessage(scriptError);
4273 return IPC_OK();
4274 }
4276 mozilla::ipc::IPCResult ContentChild::RecvReportFrameTimingData(
4277 const LoadInfoArgs& loadInfoArgs, const nsString& entryName,
4278 const nsString& initiatorType, UniquePtr<PerformanceTimingData>&& aData) {
4279 if (!aData) {
4281 }
4283 nsCOMPtr<nsILoadInfo> loadInfo;
4284 nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
4285 loadInfoArgs, NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
4286 if (NS_FAILED(rv)) {
4288 return IPC_OK();
4289 }
4291 // It is important to call LoadInfo::GetPerformanceStorage instead of simply
4292 // getting the performance object via the innerWindowID in order to perform
4293 // necessary cross origin checks.
4294 if (PerformanceStorage* storage = loadInfo->GetPerformanceStorage()) {
4295 storage->AddEntry(entryName, initiatorType, std::move(aData));
4296 }
4297 return IPC_OK();
4298 }
4300 mozilla::ipc::IPCResult ContentChild::RecvLoadURI(
4301 const MaybeDiscarded<BrowsingContext>& aContext,
4302 nsDocShellLoadState* aLoadState, bool aSetNavigating,
4303 LoadURIResolver&& aResolve) {
4304 auto resolveOnExit = MakeScopeExit([&] { aResolve(true); });
4306 if (aContext.IsNullOrDiscarded()) {
4307 return IPC_OK();
4308 }
4309 RefPtr<BrowsingContext> context = aContext.get();
4310 if (!context->IsInProcess()) {
4311 // The DocShell has been torn down or the BrowsingContext has changed
4312 // process in the middle of the load request. There's not much we can do at
4313 // this point, so just give up.
4314 return IPC_OK();
4315 }
4317 context->LoadURI(aLoadState, aSetNavigating);
4319 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4320 BrowserChild* bc = BrowserChild::GetFrom(window);
4321 if (bc) {
4322 bc->NotifyNavigationFinished();
4323 }
4325 #ifdef MOZ_CRASHREPORTER
4326 if (CrashReporter::GetEnabled()) {
4327 nsCOMPtr<nsIURI> annotationURI;
4329 nsresult rv = NS_MutateURI(aLoadState->URI())
4331 .Finalize(annotationURI);
4333 if (NS_FAILED(rv)) {
4334 // Ignore failures on about: URIs.
4335 annotationURI = aLoadState->URI();
4336 }
4338 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4339 annotationURI->GetSpecOrDefault());
4340 }
4341 #endif
4343 return IPC_OK();
4344 }
4346 mozilla::ipc::IPCResult ContentChild::RecvInternalLoad(
4347 nsDocShellLoadState* aLoadState) {
4348 if (!aLoadState->Target().IsEmpty() ||
4349 aLoadState->TargetBrowsingContext().IsNull()) {
4351 }
4352 if (aLoadState->TargetBrowsingContext().IsDiscarded()) {
4353 return IPC_OK();
4354 }
4355 RefPtr<BrowsingContext> context = aLoadState->TargetBrowsingContext().get();
4357 context->InternalLoad(aLoadState);
4359 #ifdef MOZ_CRASHREPORTER
4360 if (CrashReporter::GetEnabled()) {
4361 nsCOMPtr<nsIURI> annotationURI;
4363 nsresult rv = NS_MutateURI(aLoadState->URI())
4365 .Finalize(annotationURI);
4367 if (NS_FAILED(rv)) {
4368 // Ignore failures on about: URIs.
4369 annotationURI = aLoadState->URI();
4370 }
4372 CrashReporter::RecordAnnotationNSCString(CrashReporter::Annotation::URL,
4373 annotationURI->GetSpecOrDefault());
4374 }
4375 #endif
4377 return IPC_OK();
4378 }
4380 mozilla::ipc::IPCResult ContentChild::RecvDisplayLoadError(
4381 const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI) {
4382 if (aContext.IsNullOrDiscarded()) {
4383 return IPC_OK();
4384 }
4385 RefPtr<BrowsingContext> context = aContext.get();
4387 context->DisplayLoadError(aURI);
4389 nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
4390 BrowserChild* bc = BrowserChild::GetFrom(window);
4391 if (bc) {
4392 bc->NotifyNavigationFinished();
4393 }
4394 return IPC_OK();
4395 }
4397 mozilla::ipc::IPCResult ContentChild::RecvHistoryCommitIndexAndLength(
4398 const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
4399 const uint32_t& aLength, const nsID& aChangeID) {
4400 if (!aContext.IsNullOrDiscarded()) {
4401 ChildSHistory* shistory = aContext.get()->GetChildSessionHistory();
4402 if (shistory) {
4403 shistory->SetIndexAndLength(aIndex, aLength, aChangeID);
4404 }
4405 }
4406 return IPC_OK();
4407 }
4409 mozilla::ipc::IPCResult ContentChild::RecvGetLayoutHistoryState(
4410 const MaybeDiscarded<BrowsingContext>& aContext,
4411 GetLayoutHistoryStateResolver&& aResolver) {
4412 nsCOMPtr<nsILayoutHistoryState> state;
4413 nsIDocShell* docShell;
4414 mozilla::Maybe<mozilla::dom::Wireframe> wireframe;
4415 if (!aContext.IsNullOrDiscarded() &&
4416 (docShell = aContext.get()->GetDocShell())) {
4417 docShell->PersistLayoutHistoryState();
4418 docShell->GetLayoutHistoryState(getter_AddRefs(state));
4419 wireframe = static_cast<nsDocShell*>(docShell)->GetWireframe();
4420 }
4421 aResolver(
4422 std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&>(
4423 state, wireframe));
4425 return IPC_OK();
4426 }
4428 mozilla::ipc::IPCResult ContentChild::RecvDispatchLocationChangeEvent(
4429 const MaybeDiscarded<BrowsingContext>& aContext) {
4430 if (!aContext.IsNullOrDiscarded() && aContext.get()->GetDocShell()) {
4431 aContext.get()->GetDocShell()->DispatchLocationChangeEvent();
4432 }
4433 return IPC_OK();
4434 }
4436 mozilla::ipc::IPCResult ContentChild::RecvDispatchBeforeUnloadToSubtree(
4437 const MaybeDiscarded<BrowsingContext>& aStartingAt,
4438 DispatchBeforeUnloadToSubtreeResolver&& aResolver) {
4439 if (aStartingAt.IsNullOrDiscarded()) {
4440 aResolver(nsIDocumentViewer::eAllowNavigation);
4441 } else {
4442 DispatchBeforeUnloadToSubtree(aStartingAt.get(), std::move(aResolver));
4443 }
4444 return IPC_OK();
4445 }
4447 mozilla::ipc::IPCResult ContentChild::RecvDecoderSupportedMimeTypes(
4448 nsTArray<nsCString>&& aSupportedTypes) {
4449 #ifdef MOZ_WIDGET_ANDROID
4450 AndroidDecoderModule::SetSupportedMimeTypes(std::move(aSupportedTypes));
4451 #endif
4452 return IPC_OK();
4453 }
4455 mozilla::ipc::IPCResult ContentChild::RecvInitNextGenLocalStorageEnabled(
4456 const bool& aEnabled) {
4457 mozilla::dom::RecvInitNextGenLocalStorageEnabled(aEnabled);
4459 return IPC_OK();
4460 }
4462 /* static */ void ContentChild::DispatchBeforeUnloadToSubtree(
4463 BrowsingContext* aStartingAt,
4464 const DispatchBeforeUnloadToSubtreeResolver& aResolver) {
4465 bool resolved = false;
4467 aStartingAt->PreOrderWalk([&](dom::BrowsingContext* aBC) {
4468 if (aBC->GetDocShell()) {
4469 nsCOMPtr<nsIDocumentViewer> viewer;
4470 aBC->GetDocShell()->GetDocViewer(getter_AddRefs(viewer));
4471 if (viewer &&
4472 viewer->DispatchBeforeUnload() ==
4473 nsIDocumentViewer::eRequestBlockNavigation &&
4474 !resolved) {
4475 // Send our response as soon as we find any blocker, so that we can show
4476 // the permit unload prompt as soon as possible, without giving
4477 // subsequent handlers a chance to delay it.
4478 aResolver(nsIDocumentViewer::eRequestBlockNavigation);
4479 resolved = true;
4480 }
4481 }
4482 });
4484 if (!resolved) {
4485 aResolver(nsIDocumentViewer::eAllowNavigation);
4486 }
4487 }
4489 mozilla::ipc::IPCResult ContentChild::RecvGoBack(
4490 const MaybeDiscarded<BrowsingContext>& aContext,
4491 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4492 bool aUserActivation) {
4493 if (aContext.IsNullOrDiscarded()) {
4494 return IPC_OK();
4495 }
4496 BrowsingContext* bc = aContext.get();
4498 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4499 if (aCancelContentJSEpoch) {
4500 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4501 }
4502 docShell->GoBack(aRequireUserInteraction, aUserActivation);
4504 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4505 browserChild->NotifyNavigationFinished();
4506 }
4507 }
4509 return IPC_OK();
4510 }
4512 mozilla::ipc::IPCResult ContentChild::RecvGoForward(
4513 const MaybeDiscarded<BrowsingContext>& aContext,
4514 const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
4515 bool aUserActivation) {
4516 if (aContext.IsNullOrDiscarded()) {
4517 return IPC_OK();
4518 }
4519 BrowsingContext* bc = aContext.get();
4521 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4522 if (aCancelContentJSEpoch) {
4523 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4524 }
4525 docShell->GoForward(aRequireUserInteraction, aUserActivation);
4527 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4528 browserChild->NotifyNavigationFinished();
4529 }
4530 }
4532 return IPC_OK();
4533 }
4535 mozilla::ipc::IPCResult ContentChild::RecvGoToIndex(
4536 const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
4537 const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation) {
4538 if (aContext.IsNullOrDiscarded()) {
4539 return IPC_OK();
4540 }
4541 BrowsingContext* bc = aContext.get();
4543 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4544 if (aCancelContentJSEpoch) {
4545 docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
4546 }
4547 docShell->GotoIndex(aIndex, aUserActivation);
4549 if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
4550 browserChild->NotifyNavigationFinished();
4551 }
4552 }
4554 return IPC_OK();
4555 }
4557 mozilla::ipc::IPCResult ContentChild::RecvReload(
4558 const MaybeDiscarded<BrowsingContext>& aContext,
4559 const uint32_t aReloadFlags) {
4560 if (aContext.IsNullOrDiscarded()) {
4561 return IPC_OK();
4562 }
4563 BrowsingContext* bc = aContext.get();
4565 if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
4566 docShell->Reload(aReloadFlags);
4567 }
4569 return IPC_OK();
4570 }
4572 mozilla::ipc::IPCResult ContentChild::RecvStopLoad(
4573 const MaybeDiscarded<BrowsingContext>& aContext,
4574 const uint32_t aStopFlags) {
4575 if (aContext.IsNullOrDiscarded()) {
4576 return IPC_OK();
4577 }
4578 BrowsingContext* bc = aContext.get();
4580 if (auto* docShell = nsDocShell::Cast(bc->GetDocShell())) {
4581 docShell->Stop(aStopFlags);
4582 }
4584 return IPC_OK();
4585 }
4587 #if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
4588 mozilla::ipc::IPCResult ContentChild::RecvInitSandboxTesting(
4589 Endpoint<PSandboxTestingChild>&& aEndpoint) {
4590 if (!SandboxTestingChild::Initialize(std::move(aEndpoint))) {
4591 return IPC_FAIL(
4593 }
4594 return IPC_OK();
4595 }
4596 #endif
4598 NS_IMETHODIMP ContentChild::GetChildID(uint64_t* aOut) {
4599 *aOut = mID;
4600 return NS_OK;
4601 }
4603 NS_IMETHODIMP ContentChild::GetActor(const nsACString& aName, JSContext* aCx,
4604 JSProcessActorChild** retval) {
4605 ErrorResult error;
4606 RefPtr<JSProcessActorChild> actor =
4607 JSActorManager::GetActor(aCx, aName, error)
4608 .downcast<JSProcessActorChild>();
4609 if (error.MaybeSetPendingException(aCx)) {
4610 return NS_ERROR_FAILURE;
4611 }
4612 actor.forget(retval);
4613 return NS_OK;
4614 }
4616 NS_IMETHODIMP ContentChild::GetExistingActor(const nsACString& aName,
4617 JSProcessActorChild** retval) {
4618 RefPtr<JSProcessActorChild> actor =
4619 JSActorManager::GetExistingActor(aName).downcast<JSProcessActorChild>();
4620 actor.forget(retval);
4621 return NS_OK;
4622 }
4624 already_AddRefed<JSActor> ContentChild::InitJSActor(
4625 JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
4626 ErrorResult& aRv) {
4627 RefPtr<JSProcessActorChild> actor;
4628 if (aMaybeActor.get()) {
4629 aRv = UNWRAP_OBJECT(JSProcessActorChild, aMaybeActor.get(), actor);
4630 if (aRv.Failed()) {
4631 return nullptr;
4632 }
4633 } else {
4634 actor = new JSProcessActorChild();
4635 }
4637 MOZ_RELEASE_ASSERT(!actor->Manager(),
4639 actor->Init(aName, this);
4640 return actor.forget();
4641 }
4643 IPCResult ContentChild::RecvRawMessage(const JSActorMessageMeta& aMeta,
4644 const Maybe<ClonedMessageData>& aData,
4645 const Maybe<ClonedMessageData>& aStack) {
4646 Maybe<StructuredCloneData> data;
4647 if (aData) {
4648 data.emplace();
4649 data->BorrowFromClonedMessageData(*aData);
4650 }
4651 Maybe<StructuredCloneData> stack;
4652 if (aStack) {
4653 stack.emplace();
4654 stack->BorrowFromClonedMessageData(*aStack);
4655 }
4656 ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
4657 return IPC_OK();
4658 }
4660 NS_IMETHODIMP ContentChild::GetCanSend(bool* aCanSend) {
4661 *aCanSend = CanSend();
4662 return NS_OK;
4663 }
4665 ContentChild* ContentChild::AsContentChild() { return this; }
4667 JSActorManager* ContentChild::AsJSActorManager() { return this; }
4669 IPCResult ContentChild::RecvFlushFOGData(FlushFOGDataResolver&& aResolver) {
4670 glean::FlushFOGData(std::move(aResolver));
4671 return IPC_OK();
4672 }
4674 IPCResult ContentChild::RecvUpdateMediaCodecsSupported(
4675 RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
4676 RemoteDecoderManagerChild::SetSupported(aLocation, aSupported);
4678 return IPC_OK();
4679 }
4681 void ContentChild::ConfigureThreadPerformanceHints(
4682 const hal::ProcessPriority& aPriority) {
4683 if (aPriority >= hal::PROCESS_PRIORITY_FOREGROUND) {
4684 static bool canUsePerformanceHintSession = true;
4685 if (!mPerformanceHintSession && canUsePerformanceHintSession) {
4686 nsTArray<PlatformThreadHandle> threads;
4687 Servo_ThreadPool_GetThreadHandles(&threads);
4688 #ifdef XP_WIN
4689 threads.AppendElement(GetCurrentThread());
4690 #else
4691 threads.AppendElement(pthread_self());
4692 #endif
4694 mPerformanceHintSession = hal::CreatePerformanceHintSession(
4695 threads, GetPerformanceHintTarget(TimeDuration::FromMilliseconds(
4696 nsRefreshDriver::DefaultInterval())));
4698 // Avoid repeatedly attempting to create a session if it is not
4699 // supported.
4700 canUsePerformanceHintSession = mPerformanceHintSession != nullptr;
4701 }
4703 #ifdef MOZ_WIDGET_ANDROID
4704 // On Android if we are unable to use PerformanceHintManager then fall back
4705 // to setting the stylo threads' affinities to the performant cores. Android
4706 // automatically sets each thread's affinity to all cores when a process is
4707 // foregrounded, and to a subset of cores when the process is backgrounded.
4708 // We must therefore override this each time the process is foregrounded,
4709 // but we don't have to do anything when backgrounded.
4710 if (!mPerformanceHintSession) {
4711 if (const auto& cpuInfo = hal::GetHeterogeneousCpuInfo()) {
4712 // If CPUs are homogeneous there is no point setting affinity.
4713 if (cpuInfo->mBigCpus.Count() != cpuInfo->mTotalNumCpus) {
4714 BitSet<hal::HeterogeneousCpuInfo::MAX_CPUS> cpus = cpuInfo->mBigCpus;
4715 if (cpus.Count() < 2) {
4716 // From testing on a variety of devices it appears using only the
4717 // big cores gives best performance when there are 2 or more big
4718 // cores. If there are fewer than 2 big cores then additionally
4719 // using the medium cores performs better.
4720 cpus |= cpuInfo->mMediumCpus;
4721 }
4723 static_assert(
4724 hal::HeterogeneousCpuInfo::MAX_CPUS <= CPU_SETSIZE,
4727 cpu_set_t cpuset;
4728 CPU_ZERO(&cpuset);
4729 for (size_t i = 0; i < cpuInfo->mTotalNumCpus; i++) {
4730 if (cpus.Test(i)) {
4731 CPU_SET(i, &cpuset);
4732 }
4733 }
4735 // Only set the affinity for the stylo threads, not the main thread.
4736 // Testing showed no difference in performance between the two
4737 // options, and as newly spawned threads automatically inherit their
4738 // parent's affinity mask there may be unintended consequences to
4739 // setting the main thread affinity.
4740 nsTArray<PlatformThreadHandle> threads;
4741 Servo_ThreadPool_GetThreadHandles(&threads);
4742 for (pthread_t thread : threads) {
4743 int ret = sched_setaffinity(pthread_gettid_np(thread),
4744 sizeof(cpu_set_t), &cpuset);
4745 // Occasionally sched_setaffinity fails, presumably due to a race
4746 // between us receiving the process foreground signal and whatever
4747 // is responsible for restricting which processes can use certain
4748 // cores. Trying again in a runnable seems to do the trick, but if
4749 // that still fails it's not the end of the world.
4750 if (ret < 0) {
4751 NS_DispatchToCurrentThread(NS_NewRunnableFunction(
4753 [threads = std::move(threads), cpuset] {
4754 for (pthread_t thread : threads) {
4755 sched_setaffinity(pthread_gettid_np(thread),
4756 sizeof(cpu_set_t), &cpuset);
4757 }
4758 }));
4759 break;
4760 }
4761 }
4762 }
4763 }
4764 }
4765 #endif
4766 } else {
4767 mPerformanceHintSession = nullptr;
4768 }
4769 }
4771 } // namespace dom
4773 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
4777 NS_IMETHODIMP
4778 OpenBSDFindPledgeUnveilFilePath(const char* file, nsACString& result) {
4779 struct stat st;
4781 // Allow overriding files in /etc/$MOZ_APP_NAME
4783 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4784 return NS_OK;
4785 }
4787 // Or look in the system default directory
4788 result.Assign(nsPrintfCString(
4790 if (stat(PromiseFlatCString(result).get(), &st) == 0) {
4791 return NS_OK;
4792 }
4795 }
4797 NS_IMETHODIMP
4798 OpenBSDPledgePromises(const nsACString& aPath) {
4799 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4800 // a lot of setup before they are supported and we want to pledge early on
4801 // before all of that, so read the file directly
4802 std::ifstream input(PromiseFlatCString(aPath).get());
4804 // Build up one line of pledge promises without comments
4805 nsAutoCString promises;
4806 bool disabled = false;
4807 int linenum = 0;
4808 for (std::string tLine; std::getline(input, tLine);) {
4809 nsAutoCString line(tLine.c_str());
4810 linenum++;
4812 // Cut off any comments at the end of the line, also catches lines
4813 // that are entirely a comment
4815 if (hash >= 0) {
4816 line = Substring(line, 0, hash);
4817 }
4818 line.CompressWhitespace(true, true);
4819 if (line.IsEmpty()) {
4820 continue;
4821 }
4823 if (linenum == 1 && line.EqualsLiteral("disable")) {
4824 disabled = true;
4825 break;
4826 }
4828 if (!promises.IsEmpty()) {
4829 promises.Append(" ");
4830 }
4831 promises.Append(line);
4832 }
4833 input.close();
4835 if (disabled) {
4836 warnx("%s: disabled", PromiseFlatCString(aPath).get());
4837 } else {
4838 MOZ_LOG(
4839 sPledgeLog, LogLevel::Debug,
4841 if (pledge(promises.get(), nullptr) != 0) {
4842 err(1, "%s: pledge(%s) failed", PromiseFlatCString(aPath).get(),
4843 promises.get());
4844 }
4845 }
4847 return NS_OK;
4848 }
4850 void ExpandUnveilPath(nsAutoCString& path) {
4851 // Expand $XDG_RUNTIME_DIR to the environment variable, or ~/.cache
4852 nsCString xdgRuntimeDir(PR_GetEnv("XDG_RUNTIME_DIR"));
4853 if (xdgRuntimeDir.IsEmpty()) {
4854 xdgRuntimeDir = "~/.cache";
4855 }
4856 path.ReplaceSubstring("$XDG_RUNTIME_DIR", xdgRuntimeDir.get());
4858 // Expand $XDG_CONFIG_HOME to the environment variable, or ~/.config
4859 nsCString xdgConfigHome(PR_GetEnv("XDG_CONFIG_HOME"));
4860 if (xdgConfigHome.IsEmpty()) {
4861 xdgConfigHome = "~/.config";
4862 }
4863 path.ReplaceSubstring("$XDG_CONFIG_HOME", xdgConfigHome.get());
4865 // Expand $XDG_CACHE_HOME to the environment variable, or ~/.cache
4866 nsCString xdgCacheHome(PR_GetEnv("XDG_CACHE_HOME"));
4867 if (xdgCacheHome.IsEmpty()) {
4868 xdgCacheHome = "~/.cache";
4869 }
4870 path.ReplaceSubstring("$XDG_CACHE_HOME", xdgCacheHome.get());
4872 // Expand $XDG_DATA_HOME to the environment variable, or ~/.local/share
4873 nsCString xdgDataHome(PR_GetEnv("XDG_DATA_HOME"));
4874 if (xdgDataHome.IsEmpty()) {
4875 xdgDataHome = "~/.local/share";
4876 }
4877 path.ReplaceSubstring("$XDG_DATA_HOME", xdgDataHome.get());
4881 nsresult rv =
4885 }
4890 }
4891 }
4894 // nsLocalFile::CreateAllAncestors would be nice to use
4902 }
4911 }
4912 }
4913 }
4914 }
4916 NS_IMETHODIMP
4918 // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
4919 // a lot of setup before they are allowed/supported and we want to pledge and
4920 // unveil early on before all of that is setup
4927 linenum++;
4929 // Cut off any comments at the end of the line, also catches lines
4930 // that are entirely a comment
4934 }
4938 }
4943 }
4948 linenum);
4949 }
4962 }
4963 }
4971 // Only unveil the pledgePath file if it's not already unveiled, otherwise
4972 // some containing directory will lose visibility.
4977 }
4980 }
4981 }
4982 }
4985 }
4988 nsAutoCString pledgeFile;
4989 nsAutoCString unveilFile;
4997 // Ensure dconf dir exists before we veil the filesystem
5002 }
5033 }
5039 }
5044 }
5048 }
5052 }
5054 // Don't overwrite an existing session dbus address, but ensure it is set
5057 }
5060 }
5061 #endif
5065 /* static */
5069 }
5071 }