bf3516e81e
In modern C++, static constexpr member variables are automatically inline (aka weak) so the template trick is not needed. This also avoid duplication and reduces the amount of parsed code. No impact on generated binary (actually: smaller debuginfo, close to identical binary). Differential Revision: https://phabricator.services.mozilla.com/D247825
936 lines
34 KiB
C++
936 lines
34 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_dom_BrowserChild_h
|
|
#define mozilla_dom_BrowserChild_h
|
|
|
|
#include "mozilla/dom/ContentFrameMessageManager.h"
|
|
#include "mozilla/dom/PBrowserChild.h"
|
|
#include "nsIWebNavigation.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIWebBrowserChrome.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsIWindowProvider.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsWeakReference.h"
|
|
#include "nsIBrowserChild.h"
|
|
#include "nsITooltipListener.h"
|
|
#include "nsIWebProgressListener.h"
|
|
#include "nsIWebProgressListener2.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/dom/TabContext.h"
|
|
#include "mozilla/dom/CoalescedMouseData.h"
|
|
#include "mozilla/dom/CoalescedTouchData.h"
|
|
#include "mozilla/dom/CoalescedWheelData.h"
|
|
#include "mozilla/dom/MessageManagerCallback.h"
|
|
#include "mozilla/dom/VsyncMainChild.h"
|
|
#include "mozilla/DOMEventTargetHelper.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
|
#include "mozilla/layers/CompositorOptions.h"
|
|
#include "mozilla/layers/CompositorTypes.h"
|
|
#include "mozilla/layers/GeckoContentControllerTypes.h"
|
|
#include "mozilla/dom/ipc/IdType.h"
|
|
#include "PuppetWidget.h"
|
|
#include "nsDeque.h"
|
|
#include "nsIRemoteTab.h"
|
|
|
|
class nsBrowserStatusFilter;
|
|
class nsIDOMWindow;
|
|
class nsIHttpChannel;
|
|
class nsIRequest;
|
|
class nsISerialEventTarget;
|
|
class nsIWebProgress;
|
|
class nsWebBrowser;
|
|
class nsDocShellLoadState;
|
|
|
|
template <typename T>
|
|
class nsTHashtable;
|
|
template <typename T>
|
|
class nsPtrHashKey;
|
|
|
|
namespace mozilla {
|
|
enum class NativeKeyBindingsType : uint8_t;
|
|
|
|
class AbstractThread;
|
|
class PresShell;
|
|
|
|
namespace layers {
|
|
class APZChild;
|
|
class APZEventState;
|
|
class AsyncDragMetrics;
|
|
class IAPZCTreeManager;
|
|
class ImageCompositeNotification;
|
|
class PCompositorBridgeChild;
|
|
} // namespace layers
|
|
|
|
namespace widget {
|
|
struct AutoCacheNativeKeyCommands;
|
|
} // namespace widget
|
|
|
|
namespace dom {
|
|
|
|
class BrowserChild;
|
|
class BrowsingContext;
|
|
class TabGroup;
|
|
class ClonedMessageData;
|
|
class CoalescedMouseData;
|
|
class CoalescedWheelData;
|
|
class SessionStoreChild;
|
|
class RequestData;
|
|
class WebProgressData;
|
|
|
|
#define DOM_BROWSERCHILD_IID \
|
|
{0x58a5775d, 0xba05, 0x45bf, {0xbd, 0xb8, 0xd7, 0x61, 0xf9, 0x01, 0x01, 0x31}}
|
|
|
|
class BrowserChildMessageManager : public ContentFrameMessageManager,
|
|
public nsIMessageSender,
|
|
public nsSupportsWeakReference {
|
|
public:
|
|
explicit BrowserChildMessageManager(BrowserChild* aBrowserChild);
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BrowserChildMessageManager,
|
|
DOMEventTargetHelper)
|
|
|
|
void MarkForCC();
|
|
|
|
JSObject* WrapObject(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) override;
|
|
|
|
Nullable<WindowProxyHolder> GetContent(ErrorResult& aError) override;
|
|
already_AddRefed<nsIDocShell> GetDocShell(ErrorResult& aError) override;
|
|
already_AddRefed<nsIEventTarget> GetTabEventTarget() override;
|
|
|
|
NS_FORWARD_SAFE_NSIMESSAGESENDER(mMessageManager)
|
|
|
|
void GetEventTargetParent(EventChainPreVisitor& aVisitor) override {
|
|
aVisitor.mForceContentDispatch = true;
|
|
}
|
|
|
|
// Dispatch a runnable related to the global.
|
|
nsresult Dispatch(already_AddRefed<nsIRunnable>&& aRunnable) const;
|
|
|
|
RefPtr<BrowserChild> mBrowserChild;
|
|
|
|
protected:
|
|
~BrowserChildMessageManager();
|
|
};
|
|
|
|
/**
|
|
* BrowserChild implements the child actor part of the PBrowser protocol. See
|
|
* PBrowser for more information.
|
|
*/
|
|
class BrowserChild final : public nsMessageManagerScriptExecutor,
|
|
public ipc::MessageManagerCallback,
|
|
public PBrowserChild,
|
|
public nsIWebBrowserChrome,
|
|
public nsIInterfaceRequestor,
|
|
public nsIWindowProvider,
|
|
public nsSupportsWeakReference,
|
|
public nsIBrowserChild,
|
|
public nsIObserver,
|
|
public nsIWebProgressListener2,
|
|
public TabContext,
|
|
public nsITooltipListener,
|
|
public mozilla::ipc::IShmemAllocator {
|
|
using PuppetWidget = mozilla::widget::PuppetWidget;
|
|
using ClonedMessageData = mozilla::dom::ClonedMessageData;
|
|
using CoalescedMouseData = mozilla::dom::CoalescedMouseData;
|
|
using CoalescedWheelData = mozilla::dom::CoalescedWheelData;
|
|
using APZEventState = mozilla::layers::APZEventState;
|
|
using TouchBehaviorFlags = mozilla::layers::TouchBehaviorFlags;
|
|
|
|
friend class PBrowserChild;
|
|
|
|
public:
|
|
/**
|
|
* Find BrowserChild of aTabId in the same content process of the
|
|
* caller.
|
|
*/
|
|
static already_AddRefed<BrowserChild> FindBrowserChild(const TabId& aTabId);
|
|
|
|
// Return a list of all active BrowserChildren.
|
|
static nsTArray<RefPtr<BrowserChild>> GetAll();
|
|
|
|
public:
|
|
/**
|
|
* Create a new BrowserChild object.
|
|
*/
|
|
BrowserChild(ContentChild* aManager, const TabId& aTabId,
|
|
const TabContext& aContext,
|
|
dom::BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
|
|
bool aIsTopLevel);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult Init(mozIDOMWindowProxy* aParent,
|
|
WindowGlobalChild* aInitialWindowChild);
|
|
|
|
/** Return a BrowserChild with the given attributes. */
|
|
static already_AddRefed<BrowserChild> Create(
|
|
ContentChild* aManager, const TabId& aTabId, const TabContext& aContext,
|
|
BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
|
|
bool aIsTopLevel);
|
|
|
|
// Let managees query if it is safe to send messages.
|
|
bool IsDestroyed() const { return mDestroyed; }
|
|
|
|
TabId GetTabId() const {
|
|
MOZ_ASSERT(mUniqueId != 0);
|
|
return mUniqueId;
|
|
}
|
|
|
|
NS_INLINE_DECL_STATIC_IID(DOM_BROWSERCHILD_IID)
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_NSIWEBBROWSERCHROME
|
|
NS_DECL_NSIINTERFACEREQUESTOR
|
|
NS_DECL_NSIWINDOWPROVIDER
|
|
NS_DECL_NSIBROWSERCHILD
|
|
NS_DECL_NSIOBSERVER
|
|
NS_DECL_NSIWEBPROGRESSLISTENER
|
|
NS_DECL_NSIWEBPROGRESSLISTENER2
|
|
NS_DECL_NSITOOLTIPLISTENER
|
|
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(BrowserChild,
|
|
nsIBrowserChild)
|
|
|
|
FORWARD_SHMEM_ALLOCATOR_TO(PBrowserChild)
|
|
|
|
JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
|
|
return mBrowserChildMessageManager->WrapObject(aCx, aGivenProto);
|
|
}
|
|
|
|
// Get the Document for the top-level window in this tab.
|
|
already_AddRefed<Document> GetTopLevelDocument() const;
|
|
|
|
// Get the pres-shell of the document for the top-level window in this tab.
|
|
PresShell* GetTopLevelPresShell() const;
|
|
|
|
BrowserChildMessageManager* GetMessageManager() {
|
|
return mBrowserChildMessageManager;
|
|
}
|
|
|
|
bool IsTopLevel() const { return mIsTopLevel; }
|
|
|
|
bool ShouldSendWebProgressEventsToParent() const {
|
|
return mShouldSendWebProgressEventsToParent;
|
|
}
|
|
|
|
/**
|
|
* MessageManagerCallback methods that we override.
|
|
*/
|
|
virtual bool DoSendBlockingMessage(
|
|
const nsAString& aMessage, StructuredCloneData& aData,
|
|
nsTArray<StructuredCloneData>* aRetVal) override;
|
|
|
|
virtual nsresult DoSendAsyncMessage(const nsAString& aMessage,
|
|
StructuredCloneData& aData) override;
|
|
|
|
bool DoUpdateZoomConstraints(const uint32_t& aPresShellId,
|
|
const ViewID& aViewId,
|
|
const Maybe<ZoomConstraints>& aConstraints);
|
|
|
|
mozilla::ipc::IPCResult RecvLoadURL(nsDocShellLoadState* aLoadState,
|
|
const ParentShowInfo& aInfo);
|
|
|
|
mozilla::ipc::IPCResult RecvCreateAboutBlankDocumentViewer(
|
|
nsIPrincipal* aPrincipal, nsIPrincipal* aPartitionedPrincipal);
|
|
|
|
mozilla::ipc::IPCResult RecvResumeLoad(const uint64_t& aPendingSwitchID,
|
|
const ParentShowInfo&);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult
|
|
RecvCloneDocumentTreeIntoSelf(
|
|
const MaybeDiscarded<BrowsingContext>& aSourceBC,
|
|
const embedding::PrintData& aPrintData,
|
|
CloneDocumentTreeIntoSelfResolver&& aResolve);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvUpdateRemotePrintSettings(
|
|
const embedding::PrintData& aPrintData);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvShow(const ParentShowInfo&, const OwnerShowInfo&);
|
|
|
|
mozilla::ipc::IPCResult RecvInitRendering(
|
|
const TextureFactoryIdentifier& aTextureFactoryIdentifier,
|
|
const layers::LayersId& aLayersId,
|
|
const mozilla::layers::CompositorOptions& aCompositorOptions,
|
|
const bool& aLayersConnected);
|
|
|
|
mozilla::ipc::IPCResult RecvCompositorOptionsChanged(
|
|
const mozilla::layers::CompositorOptions& aNewOptions);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateDimensions(
|
|
const mozilla::dom::DimensionInfo& aDimensionInfo);
|
|
mozilla::ipc::IPCResult RecvSizeModeChanged(const nsSizeMode& aSizeMode);
|
|
|
|
mozilla::ipc::IPCResult RecvChildToParentMatrix(
|
|
const mozilla::Maybe<mozilla::gfx::Matrix4x4>& aMatrix,
|
|
const mozilla::ScreenRect& aTopLevelViewportVisibleRectInBrowserCoords);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvDynamicToolbarMaxHeightChanged(
|
|
const mozilla::ScreenIntCoord& aHeight);
|
|
|
|
mozilla::ipc::IPCResult RecvDynamicToolbarOffsetChanged(
|
|
const mozilla::ScreenIntCoord& aOffset);
|
|
|
|
mozilla::ipc::IPCResult RecvKeyboardHeightChanged(
|
|
const mozilla::ScreenIntCoord& aHeight);
|
|
|
|
mozilla::ipc::IPCResult RecvAndroidPipModeChanged(bool aPipMode);
|
|
|
|
mozilla::ipc::IPCResult RecvActivate(uint64_t aActionId);
|
|
|
|
mozilla::ipc::IPCResult RecvDeactivate(uint64_t aActionId);
|
|
|
|
mozilla::ipc::IPCResult RecvRealMouseMoveEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealMouseMoveEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvRealMouseMoveEventForTests(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealMouseMoveEventForTests(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvSynthMouseMoveEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPrioritySynthMouseMoveEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvRealMouseButtonEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealMouseButtonEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvRealPointerButtonEvent(
|
|
const mozilla::WidgetPointerEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealPointerButtonEvent(
|
|
const mozilla::WidgetPointerEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvRealMouseEnterExitWidgetEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealMouseEnterExitWidgetEvent(
|
|
const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvRealDragEvent(const WidgetDragEvent& aEvent,
|
|
const uint32_t& aDragAction,
|
|
const uint32_t& aDropEffect,
|
|
nsIPrincipal* aPrincipal,
|
|
nsIContentSecurityPolicy* aCsp);
|
|
|
|
mozilla::ipc::IPCResult RecvRealKeyEvent(
|
|
const mozilla::WidgetKeyboardEvent& aEvent, const nsID& aUUID);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealKeyEvent(
|
|
const mozilla::WidgetKeyboardEvent& aEvent, const nsID& aUUID);
|
|
|
|
mozilla::ipc::IPCResult RecvMouseWheelEvent(
|
|
const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityMouseWheelEvent(
|
|
const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
mozilla::ipc::IPCResult RecvRealTouchEvent(const WidgetTouchEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId,
|
|
const nsEventStatus& aApzResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealTouchEvent(
|
|
const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvRealTouchMoveEvent(
|
|
const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent(
|
|
const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvRealTouchMoveEvent2(
|
|
const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
|
|
return RecvRealTouchMoveEvent(aEvent, aGuid, aInputBlockId, aApzResponse);
|
|
}
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent2(
|
|
const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
|
|
return RecvNormalPriorityRealTouchMoveEvent(aEvent, aGuid, aInputBlockId,
|
|
aApzResponse);
|
|
}
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateSHistory();
|
|
|
|
mozilla::ipc::IPCResult RecvNativeSynthesisResponse(
|
|
const uint64_t& aObserverId, const nsCString& aResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvCompositionEvent(
|
|
const mozilla::WidgetCompositionEvent& aEvent);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityCompositionEvent(
|
|
const mozilla::WidgetCompositionEvent& aEvent);
|
|
|
|
mozilla::ipc::IPCResult RecvSelectionEvent(
|
|
const mozilla::WidgetSelectionEvent& aEvent);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPrioritySelectionEvent(
|
|
const mozilla::WidgetSelectionEvent& aEvent);
|
|
|
|
mozilla::ipc::IPCResult RecvSimpleContentCommandEvent(
|
|
const mozilla::EventMessage& aMessage);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPrioritySimpleContentCommandEvent(
|
|
const mozilla::EventMessage& aMessage);
|
|
|
|
mozilla::ipc::IPCResult RecvInsertText(const nsAString& aStringToInsert);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateRemoteStyle(
|
|
const StyleImageRendering& aImageRendering);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityInsertText(
|
|
const nsAString& aStringToInsert);
|
|
|
|
mozilla::ipc::IPCResult RecvReplaceText(const nsString& aReplaceSrcString,
|
|
const nsString& aStringToInsert,
|
|
uint32_t aOffset,
|
|
bool aPreventSetSelection);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityReplaceText(
|
|
const nsString& aReplaceSrcString, const nsString& aStringToInsert,
|
|
uint32_t aOffset, bool aPreventSetSelection);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvPasteTransferable(
|
|
const IPCTransferable& aTransferable);
|
|
|
|
mozilla::ipc::IPCResult RecvLoadRemoteScript(const nsAString& aURL,
|
|
const bool& aRunInGlobalScope);
|
|
|
|
mozilla::ipc::IPCResult RecvAsyncMessage(const nsAString& aMessage,
|
|
const ClonedMessageData& aData);
|
|
mozilla::ipc::IPCResult RecvSwappedWithOtherRemoteLoader(
|
|
const IPCTabContext& aContext);
|
|
|
|
mozilla::ipc::IPCResult RecvSafeAreaInsetsChanged(
|
|
const mozilla::LayoutDeviceIntMargin& aSafeAreaInsets);
|
|
|
|
#ifdef ACCESSIBILITY
|
|
PDocAccessibleChild* AllocPDocAccessibleChild(
|
|
PDocAccessibleChild*, const uint64_t&,
|
|
const MaybeDiscardedBrowsingContext&);
|
|
bool DeallocPDocAccessibleChild(PDocAccessibleChild*);
|
|
#endif
|
|
|
|
RefPtr<VsyncMainChild> GetVsyncChild();
|
|
|
|
nsIWebNavigation* WebNavigation() const { return mWebNav; }
|
|
|
|
PuppetWidget* WebWidget() { return mPuppetWidget; }
|
|
|
|
bool IsTransparent() const { return mIsTransparent; }
|
|
|
|
const EffectsInfo& GetEffectsInfo() const { return mEffectsInfo; }
|
|
|
|
void SetBackgroundColor(const nscolor& aColor);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual mozilla::ipc::IPCResult RecvUpdateEffects(
|
|
const EffectsInfo& aEffects);
|
|
|
|
void RequestEditCommands(NativeKeyBindingsType aType,
|
|
const WidgetKeyboardEvent& aEvent,
|
|
nsTArray<CommandInt>& aCommands);
|
|
|
|
bool IsVisible();
|
|
bool IsPreservingLayers() const { return mIsPreservingLayers; }
|
|
|
|
/**
|
|
* Signal to this BrowserChild that it should be made visible:
|
|
* activated widget, retained layer tree, etc. (Respectively,
|
|
* made not visible.)
|
|
*/
|
|
void UpdateVisibility();
|
|
void MakeVisible();
|
|
void MakeHidden();
|
|
void PresShellActivenessMaybeChanged();
|
|
|
|
ContentChild* Manager() const { return mManager; }
|
|
|
|
static inline BrowserChild* GetFrom(nsIDocShell* aDocShell) {
|
|
if (!aDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIBrowserChild> tc = aDocShell->GetBrowserChild();
|
|
return static_cast<BrowserChild*>(tc.get());
|
|
}
|
|
|
|
static inline BrowserChild* GetFrom(mozIDOMWindow* aWindow) {
|
|
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
|
|
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
|
|
return GetFrom(docShell);
|
|
}
|
|
|
|
static inline BrowserChild* GetFrom(mozIDOMWindowProxy* aWindow) {
|
|
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
|
|
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
|
|
return GetFrom(docShell);
|
|
}
|
|
|
|
static BrowserChild* GetFrom(PresShell* aPresShell);
|
|
static BrowserChild* GetFrom(layers::LayersId aLayersId);
|
|
|
|
layers::LayersId GetLayersId() { return mLayersId; }
|
|
Maybe<bool> IsLayersConnected() { return mLayersConnected; }
|
|
|
|
void DidComposite(mozilla::layers::TransactionId aTransactionId,
|
|
const TimeStamp& aCompositeStart,
|
|
const TimeStamp& aCompositeEnd);
|
|
|
|
void ClearCachedResources();
|
|
void SchedulePaint();
|
|
void ReinitRendering();
|
|
void ReinitRenderingForDeviceReset();
|
|
|
|
void NotifyJankedAnimations(const nsTArray<uint64_t>& aJankedAnimations);
|
|
|
|
static inline BrowserChild* GetFrom(nsIDOMWindow* aWindow) {
|
|
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
|
|
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
|
|
return GetFrom(docShell);
|
|
}
|
|
|
|
mozilla::ipc::IPCResult RecvUIResolutionChanged(const float& aDpi,
|
|
const int32_t& aRounding,
|
|
const double& aScale);
|
|
|
|
mozilla::ipc::IPCResult RecvHandleAccessKey(const WidgetKeyboardEvent& aEvent,
|
|
nsTArray<uint32_t>&& aCharCodes);
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvPrintPreview(const PrintData& aPrintData,
|
|
const MaybeDiscardedBrowsingContext&,
|
|
PrintPreviewResolver&& aCallback);
|
|
|
|
mozilla::ipc::IPCResult RecvExitPrintPreview();
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvPrint(
|
|
const MaybeDiscardedBrowsingContext&, const PrintData&, bool,
|
|
PrintResolver&&);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvPrintClonedPage(
|
|
const MaybeDiscardedBrowsingContext&, const PrintData&,
|
|
const MaybeDiscardedBrowsingContext&);
|
|
|
|
mozilla::ipc::IPCResult RecvDestroyPrintClone(
|
|
const MaybeDiscardedBrowsingContext&);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateNativeWindowHandle(
|
|
const uintptr_t& aNewHandle);
|
|
|
|
mozilla::ipc::IPCResult RecvWillChangeProcess();
|
|
|
|
PPaymentRequestChild* AllocPPaymentRequestChild();
|
|
|
|
bool DeallocPPaymentRequestChild(PPaymentRequestChild* aActor);
|
|
|
|
LayoutDeviceIntPoint GetClientOffset() const { return mClientOffset; }
|
|
LayoutDeviceIntPoint GetChromeOffset() const { return mChromeOffset; };
|
|
ScreenIntCoord GetDynamicToolbarMaxHeight() const {
|
|
return mDynamicToolbarMaxHeight;
|
|
};
|
|
mozilla::ScreenIntCoord GetKeyboardHeight() const { return mKeyboardHeight; }
|
|
|
|
bool InAndroidPipMode() const { return mInAndroidPipMode; }
|
|
|
|
bool IPCOpen() const { return mIPCOpen; }
|
|
|
|
const mozilla::layers::CompositorOptions& GetCompositorOptions() const;
|
|
bool AsyncPanZoomEnabled() const;
|
|
|
|
LayoutDeviceIntSize GetInnerSize();
|
|
CSSSize GetUnscaledInnerSize() { return mUnscaledInnerSize; }
|
|
|
|
Maybe<nsRect> GetVisibleRect() const;
|
|
|
|
// Call RecvShow(nsIntSize(0, 0)) and block future calls to RecvShow().
|
|
void DoFakeShow(const ParentShowInfo&);
|
|
|
|
void ContentReceivedInputBlock(uint64_t aInputBlockId,
|
|
bool aPreventDefault) const;
|
|
void SetTargetAPZC(
|
|
uint64_t aInputBlockId,
|
|
const nsTArray<layers::ScrollableLayerGuid>& aTargets) const;
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvHandleTap(
|
|
const layers::GeckoContentController_TapType& aType,
|
|
const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
|
|
const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId,
|
|
const Maybe<DoubleTapToZoomMetrics>& aDoubleTapToZoomMetrics);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvNormalPriorityHandleTap(
|
|
const layers::GeckoContentController_TapType& aType,
|
|
const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
|
|
const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId,
|
|
const Maybe<DoubleTapToZoomMetrics>& aDoubleTapToZoomMetrics);
|
|
|
|
bool UpdateFrame(const layers::RepaintRequest& aRequest);
|
|
void NotifyAPZStateChange(
|
|
const ViewID& aViewId,
|
|
const layers::GeckoContentController_APZStateChange& aChange,
|
|
const int& aArg, Maybe<uint64_t> aInputBlockId);
|
|
void StartScrollbarDrag(const layers::AsyncDragMetrics& aDragMetrics);
|
|
void ZoomToRect(const uint32_t& aPresShellId,
|
|
const ScrollableLayerGuid::ViewID& aViewId,
|
|
const CSSRect& aRect, const uint32_t& aFlags);
|
|
|
|
// Request that the docshell be marked as active.
|
|
void PaintWhileInterruptingJS();
|
|
|
|
void UnloadLayersWhileInterruptingJS();
|
|
|
|
nsresult CanCancelContentJS(nsIRemoteTab::NavigationType aNavigationType,
|
|
int32_t aNavigationIndex, nsIURI* aNavigationURI,
|
|
int32_t aEpoch, bool* aCanCancel);
|
|
|
|
#if defined(XP_WIN) && defined(ACCESSIBILITY)
|
|
uintptr_t GetNativeWindowHandle() const { return mNativeWindowHandle; }
|
|
#endif
|
|
|
|
BrowsingContext* GetBrowsingContext() const { return mBrowsingContext; }
|
|
|
|
// The transform from the coordinate space of this BrowserChild to the
|
|
// coordinate space of the native window its BrowserParent is in.
|
|
mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
|
|
GetChildToParentConversionMatrix() const;
|
|
|
|
// Returns the portion of the visible rect of this remote document in the
|
|
// top browser window coordinate system. This is the result of being
|
|
// clipped by all ancestor viewports.
|
|
Maybe<ScreenRect> GetTopLevelViewportVisibleRectInBrowserCoords() const;
|
|
|
|
// Similar to above GetTopLevelViewportVisibleRectInBrowserCoords(), but
|
|
// in this out-of-process document's coordinate system.
|
|
Maybe<LayoutDeviceRect> GetTopLevelViewportVisibleRectInSelfCoords() const;
|
|
|
|
// Prepare to dispatch all coalesced mousemove events. We'll move all data
|
|
// in mCoalescedMouseData to a nsDeque; then we start processing them. We
|
|
// can't fetch the coalesced event one by one and dispatch it because we
|
|
// may reentry the event loop and access to the same hashtable. It's
|
|
// called when dispatching some mouse events other than mousemove.
|
|
void FlushAllCoalescedMouseData();
|
|
void ProcessPendingCoalescedMouseDataAndDispatchEvents();
|
|
|
|
void ProcessPendingCoalescedTouchData();
|
|
|
|
void HandleRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
void SetCancelContentJSEpoch(int32_t aEpoch) {
|
|
mCancelContentJSEpoch = aEpoch;
|
|
}
|
|
|
|
void UpdateSessionStore();
|
|
|
|
mozilla::dom::SessionStoreChild* GetSessionStoreChild() {
|
|
return mSessionStoreChild;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
// Check if the window this BrowserChild is associated with supports
|
|
// protected media (EME) or not.
|
|
// Returns a promise the will resolve true if the window supports
|
|
// protected media or false if it does not. The promise will be rejected
|
|
// with an ResponseRejectReason if the IPC needed to do the check fails.
|
|
// Callers should treat the reject case as if the window does not support
|
|
// protected media to ensure robust handling.
|
|
RefPtr<IsWindowSupportingProtectedMediaPromise>
|
|
DoesWindowSupportProtectedMedia();
|
|
#endif
|
|
|
|
// Notify the content blocking event in the parent process. This sends an
|
|
// IPC message to the BrowserParent in the parent. The BrowserParent will
|
|
// find the top-level WindowGlobalParent and notify the event from it.
|
|
void NotifyContentBlockingEvent(
|
|
uint32_t aEvent, nsIChannel* aChannel, bool aBlocked,
|
|
const nsACString& aTrackingOrigin,
|
|
const nsTArray<nsCString>& aTrackingFullHashes,
|
|
const Maybe<
|
|
ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
|
|
aReason,
|
|
const Maybe<ContentBlockingNotifier::CanvasFingerprinter>&
|
|
aCanvasFingerprinter,
|
|
const Maybe<bool> aCanvasFingerprinterKnownText);
|
|
|
|
already_AddRefed<nsIDragSession> GetDragSession();
|
|
void SetDragSession(nsIDragSession* aSession);
|
|
|
|
mozilla::ipc::IPCResult RecvInvokeChildDragSession(
|
|
const MaybeDiscarded<WindowContext>& aSourceWindowContext,
|
|
const MaybeDiscarded<WindowContext>& aSourceTopWindowContext,
|
|
nsIPrincipal* aPrincipal, nsTArray<IPCTransferableData>&& aTransferables,
|
|
const uint32_t& aAction);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateDragSession(
|
|
nsIPrincipal* aPrincipal, nsTArray<IPCTransferableData>&& aTransferables,
|
|
EventMessage aEventMessage);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvEndDragSession(
|
|
const bool& aDoneDrag, const bool& aUserCancelled,
|
|
const mozilla::LayoutDeviceIntPoint& aEndDragPoint,
|
|
const uint32_t& aKeyModifiers, const uint32_t& aDropEffect);
|
|
|
|
mozilla::ipc::IPCResult RecvStoreDropTargetAndDelayEndDragSession(
|
|
const LayoutDeviceIntPoint& aPt, uint32_t aDropEffect,
|
|
uint32_t aDragAction, nsIPrincipal* aPrincipal,
|
|
nsIContentSecurityPolicy* aCsp);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvDispatchToDropTargetAndResumeEndDragSession(
|
|
bool aShouldDrop);
|
|
|
|
protected:
|
|
virtual ~BrowserChild();
|
|
|
|
mozilla::ipc::IPCResult RecvDestroy();
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvRenderLayers(const bool& aEnabled);
|
|
|
|
mozilla::ipc::IPCResult RecvPreserveLayers(bool);
|
|
|
|
mozilla::ipc::IPCResult RecvNavigateByKey(const bool& aForward,
|
|
const bool& aForDocumentNavigation);
|
|
|
|
mozilla::ipc::IPCResult RecvSuppressDisplayport(const bool& aEnabled);
|
|
|
|
mozilla::ipc::IPCResult RecvScrollbarPreferenceChanged(ScrollbarPreference);
|
|
|
|
mozilla::ipc::IPCResult RecvStopIMEStateManagement();
|
|
|
|
mozilla::ipc::IPCResult RecvAllowScriptsToClose();
|
|
|
|
mozilla::ipc::IPCResult RecvReleaseAllPointerCapture();
|
|
|
|
mozilla::ipc::IPCResult RecvReleasePointerLock();
|
|
|
|
private:
|
|
void HandleDoubleTap(const CSSPoint& aPoint, const Modifiers& aModifiers,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const DoubleTapToZoomMetrics& aMetrics);
|
|
|
|
void ActorDestroy(ActorDestroyReason why) override;
|
|
|
|
bool InitBrowserChildMessageManager();
|
|
|
|
void InitRenderingState(
|
|
const TextureFactoryIdentifier& aTextureFactoryIdentifier,
|
|
const layers::LayersId& aLayersId,
|
|
const mozilla::layers::CompositorOptions& aCompositorOptions);
|
|
void InitAPZState();
|
|
|
|
void DestroyWindow();
|
|
|
|
void ApplyParentShowInfo(const ParentShowInfo&);
|
|
|
|
bool HasValidInnerSize();
|
|
|
|
LayoutDeviceIntRect GetOuterRect();
|
|
|
|
void SetUnscaledInnerSize(const CSSSize& aSize) {
|
|
mUnscaledInnerSize = aSize;
|
|
}
|
|
|
|
bool SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent);
|
|
|
|
void UpdateRepeatedKeyEventEndTime(const WidgetKeyboardEvent& aEvent);
|
|
|
|
void DispatchCoalescedWheelEvent();
|
|
|
|
/**
|
|
* Dispatch aEvent on aEvent.mWidget.
|
|
*/
|
|
nsEventStatus DispatchWidgetEventViaAPZ(WidgetGUIEvent& aEvent);
|
|
|
|
void DispatchWheelEvent(const WidgetWheelEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
void InternalSetDocShellIsActive(bool aIsActive);
|
|
|
|
MOZ_CAN_RUN_SCRIPT
|
|
mozilla::ipc::IPCResult CommonPrint(
|
|
const MaybeDiscardedBrowsingContext& aBc, const PrintData& aPrintData,
|
|
RefPtr<BrowsingContext>* aCachedBrowsingContext);
|
|
|
|
bool CreateRemoteLayerManager(
|
|
mozilla::layers::PCompositorBridgeChild* aCompositorChild);
|
|
|
|
nsresult PrepareRequestData(nsIRequest* aRequest, RequestData& aRequestData);
|
|
nsresult PrepareProgressListenerData(nsIWebProgress* aWebProgress,
|
|
nsIRequest* aRequest,
|
|
WebProgressData& aWebProgressData,
|
|
RequestData& aRequestData);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
nsresult UpdateRemotePrintSettings(const embedding::PrintData& aPrintData);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
nsresult CloneDocumentTreeIntoSelf(
|
|
const MaybeDiscarded<BrowsingContext>& aSourceBC,
|
|
const embedding::PrintData& aPrintData);
|
|
|
|
already_AddRefed<DataTransfer> ConvertToDataTransfer(
|
|
nsIPrincipal* aPrincipal, nsTArray<IPCTransferableData>&& aTransferables,
|
|
EventMessage aMessage);
|
|
|
|
class DelayedDeleteRunnable;
|
|
|
|
RefPtr<BrowserChildMessageManager> mBrowserChildMessageManager;
|
|
TextureFactoryIdentifier mTextureFactoryIdentifier;
|
|
RefPtr<nsWebBrowser> mWebBrowser;
|
|
nsCOMPtr<nsIWebNavigation> mWebNav;
|
|
RefPtr<PuppetWidget> mPuppetWidget;
|
|
nsCOMPtr<nsIURI> mLastURI;
|
|
RefPtr<ContentChild> mManager;
|
|
RefPtr<BrowsingContext> mBrowsingContext;
|
|
RefPtr<nsBrowserStatusFilter> mStatusFilter;
|
|
RefPtr<nsIDragSession> mDragSession;
|
|
|
|
Maybe<CodeNameIndex> mPreviousConsumedKeyDownCode;
|
|
uint32_t mChromeFlags;
|
|
uint32_t mMaxTouchPoints;
|
|
layers::LayersId mLayersId;
|
|
CSSRect mUnscaledOuterRect;
|
|
Maybe<bool> mLayersConnected;
|
|
Maybe<bool> mLayersConnectRequested;
|
|
EffectsInfo mEffectsInfo;
|
|
|
|
RefPtr<APZEventState> mAPZEventState;
|
|
|
|
// Position of client area relative to the outer window
|
|
LayoutDeviceIntPoint mClientOffset;
|
|
// Position of tab, relative to parent widget (typically the window)
|
|
// NOTE: This value is valuable only for the top level browser.
|
|
LayoutDeviceIntPoint mChromeOffset;
|
|
ScreenIntCoord mDynamicToolbarMaxHeight;
|
|
// The software keyboard height.
|
|
ScreenIntCoord mKeyboardHeight;
|
|
TabId mUniqueId;
|
|
|
|
// Position of a delayed drop event.
|
|
LayoutDeviceIntPoint mDelayedDropPoint;
|
|
|
|
bool mDidFakeShow : 1;
|
|
bool mTriedBrowserInit : 1;
|
|
bool mHasValidInnerSize : 1;
|
|
bool mDestroyed : 1;
|
|
// Whether we're in Android's PiP mode.
|
|
bool mInAndroidPipMode : 1;
|
|
|
|
// Whether or not this browser is the child part of the top level PBrowser
|
|
// actor in a remote browser.
|
|
bool mIsTopLevel : 1;
|
|
|
|
bool mIsTransparent : 1;
|
|
bool mIPCOpen : 1;
|
|
|
|
bool mDidSetRealShowInfo : 1;
|
|
bool mDidLoadURLInit : 1;
|
|
|
|
bool mSkipKeyPress : 1;
|
|
|
|
bool mCoalesceMouseMoveEvents : 1;
|
|
|
|
bool mShouldSendWebProgressEventsToParent : 1;
|
|
|
|
// Whether we are rendering to the compositor or not.
|
|
bool mRenderLayers : 1;
|
|
|
|
// Whether we're artificially preserving layers.
|
|
bool mIsPreservingLayers : 1;
|
|
|
|
// Holds the compositor options for the compositor rendering this tab,
|
|
// once we find out which compositor that is.
|
|
Maybe<mozilla::layers::CompositorOptions> mCompositorOptions;
|
|
|
|
friend class ContentChild;
|
|
|
|
CSSSize mUnscaledInnerSize;
|
|
|
|
// Store the end time of the handling of the last repeated
|
|
// keydown/keypress event so that in case event handling takes time, some
|
|
// repeated events can be skipped to not flood child process.
|
|
mozilla::TimeStamp mRepeatedKeyEventTime;
|
|
|
|
// Similar to mRepeatedKeyEventTime, store the end time (from parent
|
|
// process) of handling the last repeated wheel event so that in case
|
|
// event handling takes time, some repeated events can be skipped to not
|
|
// flood child process.
|
|
mozilla::TimeStamp mLastWheelProcessedTimeFromParent;
|
|
mozilla::TimeDuration mLastWheelProcessingDuration;
|
|
|
|
// Hash table to track coalesced mousemove events for different pointers.
|
|
nsClassHashtable<nsUint32HashKey, CoalescedMouseData> mCoalescedMouseData;
|
|
|
|
nsDeque<CoalescedMouseData> mToBeDispatchedMouseData;
|
|
|
|
CoalescedWheelData mCoalescedWheelData;
|
|
CoalescedTouchData mCoalescedTouchData;
|
|
|
|
RefPtr<CoalescedMouseMoveFlusher> mCoalescedMouseEventFlusher;
|
|
RefPtr<CoalescedTouchMoveFlusher> mCoalescedTouchMoveEventFlusher;
|
|
|
|
RefPtr<layers::IAPZCTreeManager> mApzcTreeManager;
|
|
RefPtr<SessionStoreChild> mSessionStoreChild;
|
|
|
|
#if defined(XP_WIN) && defined(ACCESSIBILITY)
|
|
// The handle associated with the native window that contains this tab
|
|
uintptr_t mNativeWindowHandle;
|
|
#endif // defined(XP_WIN)
|
|
|
|
int32_t mCancelContentJSEpoch;
|
|
|
|
Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> mChildToParentConversionMatrix;
|
|
// When mChildToParentConversionMatrix is Nothing() this value is invalid.
|
|
ScreenRect mTopLevelViewportVisibleRectInBrowserCoords;
|
|
|
|
#ifdef XP_WIN
|
|
// Should only be accessed on main thread.
|
|
Maybe<bool> mWindowSupportsProtectedMedia;
|
|
#endif
|
|
|
|
// If set, resolve when we receive ChildToParentMatrix.
|
|
RefPtr<dom::Promise> mContentTransformPromise;
|
|
|
|
DISALLOW_EVIL_CONSTRUCTORS(BrowserChild);
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_dom_BrowserChild_h
|