summaryrefslogtreecommitdiffstats
path: root/dom/ipc/TabParent.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/ipc/TabParent.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/ipc/TabParent.h')
-rw-r--r--dom/ipc/TabParent.h813
1 files changed, 813 insertions, 0 deletions
diff --git a/dom/ipc/TabParent.h b/dom/ipc/TabParent.h
new file mode 100644
index 000000000..43afb0538
--- /dev/null
+++ b/dom/ipc/TabParent.h
@@ -0,0 +1,813 @@
+/* -*- 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_tabs_TabParent_h
+#define mozilla_tabs_TabParent_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/ContentCache.h"
+#include "mozilla/dom/AudioChannelBinding.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/PBrowserParent.h"
+#include "mozilla/dom/PContent.h"
+#include "mozilla/dom/PFilePickerParent.h"
+#include "mozilla/dom/TabContext.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Move.h"
+#include "nsCOMPtr.h"
+#include "nsIAuthPromptProvider.h"
+#include "nsIBrowserDOMWindow.h"
+#include "nsIDOMEventListener.h"
+#include "nsIKeyEventInPluginCallback.h"
+#include "nsISecureBrowserUI.h"
+#include "nsITabParent.h"
+#include "nsIWebBrowserPersistable.h"
+#include "nsIXULBrowserWindow.h"
+#include "nsRefreshDriver.h"
+#include "nsWeakReference.h"
+#include "Units.h"
+#include "nsIWidget.h"
+#include "nsIPartialSHistory.h"
+
+class nsFrameLoader;
+class nsIFrameLoader;
+class nsIContent;
+class nsIPrincipal;
+class nsIURI;
+class nsILoadContext;
+class nsIDocShell;
+
+namespace mozilla {
+
+namespace a11y {
+class DocAccessibleParent;
+}
+
+namespace jsipc {
+class CpowHolder;
+} // namespace jsipc
+
+namespace layers {
+struct TextureFactoryIdentifier;
+} // namespace layers
+
+namespace layout {
+class RenderFrameParent;
+} // namespace layout
+
+namespace widget {
+struct IMENotification;
+} // namespace widget
+
+namespace gfx {
+class SourceSurface;
+class DataSourceSurface;
+} // namespace gfx
+
+namespace dom {
+
+class ClonedMessageData;
+class nsIContentParent;
+class Element;
+class DataTransfer;
+
+namespace ipc {
+class StructuredCloneData;
+} // ipc namespace
+
+class TabParent final : public PBrowserParent
+ , public nsIDOMEventListener
+ , public nsITabParent
+ , public nsIAuthPromptProvider
+ , public nsISecureBrowserUI
+ , public nsIKeyEventInPluginCallback
+ , public nsSupportsWeakReference
+ , public TabContext
+ , public nsAPostRefreshObserver
+ , public nsIWebBrowserPersistable
+{
+ typedef mozilla::dom::ClonedMessageData ClonedMessageData;
+
+ virtual ~TabParent();
+
+public:
+ // Helper class for ContentParent::RecvCreateWindow.
+ struct AutoUseNewTab;
+
+ // nsITabParent
+ NS_DECL_NSITABPARENT
+ // nsIDOMEventListener interfaces
+ NS_DECL_NSIDOMEVENTLISTENER
+
+ TabParent(nsIContentParent* aManager,
+ const TabId& aTabId,
+ const TabContext& aContext,
+ uint32_t aChromeFlags);
+
+ Element* GetOwnerElement() const { return mFrameElement; }
+ already_AddRefed<nsPIDOMWindowOuter> GetParentWindowOuter();
+
+ void SetOwnerElement(Element* aElement);
+
+ void CacheFrameLoader(nsFrameLoader* aFrameLoader);
+
+ /**
+ * Get the mozapptype attribute from this TabParent's owner DOM element.
+ */
+ void GetAppType(nsAString& aOut);
+
+ /**
+ * Returns true iff this TabParent's nsIFrameLoader is visible.
+ *
+ * The frameloader's visibility can be independent of e.g. its docshell's
+ * visibility.
+ */
+ bool IsVisible() const;
+
+ nsIBrowserDOMWindow *GetBrowserDOMWindow() const { return mBrowserDOMWindow; }
+
+ void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserDOMWindow)
+ {
+ mBrowserDOMWindow = aBrowserDOMWindow;
+ }
+
+ void SetHasContentOpener(bool aHasContentOpener);
+
+ void SwapFrameScriptsFrom(nsTArray<FrameScriptInfo>& aFrameScripts)
+ {
+ aFrameScripts.SwapElements(mDelayedFrameScripts);
+ }
+
+ already_AddRefed<nsILoadContext> GetLoadContext();
+
+ already_AddRefed<nsIWidget> GetTopLevelWidget();
+
+ nsIXULBrowserWindow* GetXULBrowserWindow();
+
+ void Destroy();
+
+ void RemoveWindowListeners();
+
+ void AddWindowListeners();
+
+ void DidRefresh() override;
+
+ virtual bool RecvMoveFocus(const bool& aForward,
+ const bool& aForDocumentNavigation) override;
+
+ virtual bool RecvSizeShellTo(const uint32_t& aFlags,
+ const int32_t& aWidth,
+ const int32_t& aHeight,
+ const int32_t& aShellItemWidth,
+ const int32_t& aShellItemHeight) override;
+
+ virtual bool RecvDropLinks(nsTArray<nsString>&& aLinks) override;
+
+ virtual bool RecvEvent(const RemoteDOMEvent& aEvent) override;
+
+ virtual bool RecvReplyKeyEvent(const WidgetKeyboardEvent& aEvent) override;
+
+ virtual bool
+ RecvDispatchAfterKeyboardEvent(const WidgetKeyboardEvent& aEvent) override;
+
+ virtual bool
+ RecvAccessKeyNotHandled(const WidgetKeyboardEvent& aEvent) override;
+
+ virtual bool RecvBrowserFrameOpenWindow(PBrowserParent* aOpener,
+ PRenderFrameParent* aRenderFrame,
+ const nsString& aURL,
+ const nsString& aName,
+ const nsString& aFeatures,
+ bool* aOutWindowOpened,
+ TextureFactoryIdentifier* aTextureFactoryIdentifier,
+ uint64_t* aLayersId) override;
+
+ virtual bool
+ RecvSyncMessage(const nsString& aMessage,
+ const ClonedMessageData& aData,
+ InfallibleTArray<CpowEntry>&& aCpows,
+ const IPC::Principal& aPrincipal,
+ nsTArray<ipc::StructuredCloneData>* aRetVal) override;
+
+ virtual bool
+ RecvRpcMessage(const nsString& aMessage,
+ const ClonedMessageData& aData,
+ InfallibleTArray<CpowEntry>&& aCpows,
+ const IPC::Principal& aPrincipal,
+ nsTArray<ipc::StructuredCloneData>* aRetVal) override;
+
+ virtual bool RecvAsyncMessage(const nsString& aMessage,
+ InfallibleTArray<CpowEntry>&& aCpows,
+ const IPC::Principal& aPrincipal,
+ const ClonedMessageData& aData) override;
+
+ virtual bool
+ RecvNotifyIMEFocus(const ContentCache& aContentCache,
+ const widget::IMENotification& aEventMessage,
+ nsIMEUpdatePreference* aPreference) override;
+
+ virtual bool
+ RecvNotifyIMETextChange(const ContentCache& aContentCache,
+ const widget::IMENotification& aEventMessage) override;
+
+ virtual bool
+ RecvNotifyIMECompositionUpdate(const ContentCache& aContentCache,
+ const widget::IMENotification& aEventMessage) override;
+
+ virtual bool
+ RecvNotifyIMESelection(const ContentCache& aContentCache,
+ const widget::IMENotification& aEventMessage) override;
+
+ virtual bool
+ RecvUpdateContentCache(const ContentCache& aContentCache) override;
+
+ virtual bool
+ RecvNotifyIMEMouseButtonEvent(const widget::IMENotification& aEventMessage,
+ bool* aConsumedByIME) override;
+
+ virtual bool
+ RecvNotifyIMEPositionChange(const ContentCache& aContentCache,
+ const widget::IMENotification& aEventMessage) override;
+
+ virtual bool
+ RecvOnEventNeedingAckHandled(const EventMessage& aMessage) override;
+
+ virtual bool
+ RecvRequestIMEToCommitComposition(const bool& aCancel,
+ bool* aIsCommitted,
+ nsString* aCommittedString) override;
+
+ virtual bool
+ RecvStartPluginIME(const WidgetKeyboardEvent& aKeyboardEvent,
+ const int32_t& aPanelX,
+ const int32_t& aPanelY,
+ nsString* aCommitted) override;
+
+ virtual bool RecvSetPluginFocused(const bool& aFocused) override;
+
+ virtual bool RecvSetCandidateWindowForPlugin(
+ const widget::CandidateWindowPosition& aPosition) override;
+
+ virtual bool
+ RecvDefaultProcOfPluginEvent(const WidgetPluginEvent& aEvent) override;
+
+ virtual bool RecvGetInputContext(int32_t* aIMEEnabled,
+ int32_t* aIMEOpen) override;
+
+ virtual bool RecvSetInputContext(const int32_t& aIMEEnabled,
+ const int32_t& aIMEOpen,
+ const nsString& aType,
+ const nsString& aInputmode,
+ const nsString& aActionHint,
+ const int32_t& aCause,
+ const int32_t& aFocusChange) override;
+
+
+ // See nsIKeyEventInPluginCallback
+ virtual void HandledWindowedPluginKeyEvent(
+ const NativeEventData& aKeyEventData,
+ bool aIsConsumed) override;
+
+ virtual bool RecvOnWindowedPluginKeyEvent(
+ const NativeEventData& aKeyEventData) override;
+
+ virtual bool RecvRequestFocus(const bool& aCanRaise) override;
+
+ virtual bool RecvLookUpDictionary(
+ const nsString& aText,
+ nsTArray<mozilla::FontRange>&& aFontRangeArray,
+ const bool& aIsVertical,
+ const LayoutDeviceIntPoint& aPoint) override;
+
+ virtual bool
+ RecvEnableDisableCommands(const nsString& aAction,
+ nsTArray<nsCString>&& aEnabledCommands,
+ nsTArray<nsCString>&& aDisabledCommands) override;
+
+ virtual bool
+ RecvSetCursor(const uint32_t& aValue, const bool& aForce) override;
+
+ virtual bool RecvSetCustomCursor(const nsCString& aUri,
+ const uint32_t& aWidth,
+ const uint32_t& aHeight,
+ const uint32_t& aStride,
+ const uint8_t& aFormat,
+ const uint32_t& aHotspotX,
+ const uint32_t& aHotspotY,
+ const bool& aForce) override;
+
+ virtual bool RecvSetStatus(const uint32_t& aType,
+ const nsString& aStatus) override;
+
+ virtual bool RecvIsParentWindowMainWidgetVisible(bool* aIsVisible) override;
+
+ virtual bool RecvShowTooltip(const uint32_t& aX,
+ const uint32_t& aY,
+ const nsString& aTooltip,
+ const nsString& aDirection) override;
+
+ virtual bool RecvHideTooltip() override;
+
+ virtual bool RecvGetDPI(float* aValue) override;
+
+ virtual bool RecvGetDefaultScale(double* aValue) override;
+
+ virtual bool RecvGetWidgetRounding(int32_t* aValue) override;
+
+ virtual bool RecvGetMaxTouchPoints(uint32_t* aTouchPoints) override;
+
+ virtual bool RecvGetWidgetNativeData(WindowsHandle* aValue) override;
+
+ virtual bool RecvSetNativeChildOfShareableWindow(const uintptr_t& childWindow) override;
+
+ virtual bool RecvDispatchFocusToTopLevelWindow() override;
+
+ virtual bool RecvRespondStartSwipeEvent(const uint64_t& aInputBlockId,
+ const bool& aStartSwipe) override;
+
+ virtual bool
+ RecvDispatchWheelEvent(const mozilla::WidgetWheelEvent& aEvent) override;
+
+ virtual bool
+ RecvDispatchMouseEvent(const mozilla::WidgetMouseEvent& aEvent) override;
+
+ virtual bool
+ RecvDispatchKeyboardEvent(const mozilla::WidgetKeyboardEvent& aEvent) override;
+
+ virtual PColorPickerParent*
+ AllocPColorPickerParent(const nsString& aTitle,
+ const nsString& aInitialColor) override;
+
+ virtual bool
+ DeallocPColorPickerParent(PColorPickerParent* aColorPicker) override;
+
+ virtual PDatePickerParent*
+ AllocPDatePickerParent(const nsString& aTitle, const nsString& aInitialDate) override;
+ virtual bool DeallocPDatePickerParent(PDatePickerParent* aDatePicker) override;
+
+ virtual PDocAccessibleParent*
+ AllocPDocAccessibleParent(PDocAccessibleParent*, const uint64_t&,
+ const uint32_t&, const IAccessibleHolder&) override;
+
+ virtual bool DeallocPDocAccessibleParent(PDocAccessibleParent*) override;
+
+ virtual bool
+ RecvPDocAccessibleConstructor(PDocAccessibleParent* aDoc,
+ PDocAccessibleParent* aParentDoc,
+ const uint64_t& aParentID,
+ const uint32_t& aMsaaID,
+ const IAccessibleHolder& aDocCOMProxy) override;
+
+ /**
+ * Return the top level doc accessible parent for this tab.
+ */
+ a11y::DocAccessibleParent* GetTopLevelDocAccessible() const;
+
+ void LoadURL(nsIURI* aURI);
+
+ // XXX/cjones: it's not clear what we gain by hiding these
+ // message-sending functions under a layer of indirection and
+ // eating the return values
+ void Show(const ScreenIntSize& aSize, bool aParentIsActive);
+
+ void UpdateDimensions(const nsIntRect& aRect, const ScreenIntSize& aSize);
+
+ void SizeModeChanged(const nsSizeMode& aSizeMode);
+
+ void UIResolutionChanged();
+
+ void ThemeChanged();
+
+ void HandleAccessKey(const WidgetKeyboardEvent& aEvent,
+ nsTArray<uint32_t>& aCharCodes,
+ const int32_t& aModifierMask);
+
+ void Activate();
+
+ void Deactivate();
+
+ bool MapEventCoordinatesForChildProcess(mozilla::WidgetEvent* aEvent);
+
+ void MapEventCoordinatesForChildProcess(const LayoutDeviceIntPoint& aOffset,
+ mozilla::WidgetEvent* aEvent);
+
+ LayoutDeviceToCSSScale GetLayoutDeviceToCSSScale();
+
+ virtual bool
+ RecvRequestNativeKeyBindings(const mozilla::WidgetKeyboardEvent& aEvent,
+ MaybeNativeKeyBinding* aBindings) override;
+
+ virtual bool
+ RecvSynthesizeNativeKeyEvent(const int32_t& aNativeKeyboardLayout,
+ const int32_t& aNativeKeyCode,
+ const uint32_t& aModifierFlags,
+ const nsString& aCharacters,
+ const nsString& aUnmodifiedCharacters,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvSynthesizeNativeMouseEvent(const LayoutDeviceIntPoint& aPoint,
+ const uint32_t& aNativeMessage,
+ const uint32_t& aModifierFlags,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvSynthesizeNativeMouseMove(const LayoutDeviceIntPoint& aPoint,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvSynthesizeNativeMouseScrollEvent(const LayoutDeviceIntPoint& aPoint,
+ const uint32_t& aNativeMessage,
+ const double& aDeltaX,
+ const double& aDeltaY,
+ const double& aDeltaZ,
+ const uint32_t& aModifierFlags,
+ const uint32_t& aAdditionalFlags,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvSynthesizeNativeTouchPoint(const uint32_t& aPointerId,
+ const TouchPointerState& aPointerState,
+ const LayoutDeviceIntPoint& aPoint,
+ const double& aPointerPressure,
+ const uint32_t& aPointerOrientation,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvSynthesizeNativeTouchTap(const LayoutDeviceIntPoint& aPoint,
+ const bool& aLongTap,
+ const uint64_t& aObserverId) override;
+
+ virtual bool
+ RecvClearNativeTouchSequence(const uint64_t& aObserverId) override;
+
+ void SendMouseEvent(const nsAString& aType, float aX, float aY,
+ int32_t aButton, int32_t aClickCount,
+ int32_t aModifiers, bool aIgnoreRootScrollFrame);
+
+ void SendKeyEvent(const nsAString& aType, int32_t aKeyCode,
+ int32_t aCharCode, int32_t aModifiers,
+ bool aPreventDefault);
+
+ bool SendRealMouseEvent(mozilla::WidgetMouseEvent& event);
+
+ bool SendRealDragEvent(mozilla::WidgetDragEvent& aEvent,
+ uint32_t aDragAction,
+ uint32_t aDropEffect);
+
+ bool SendMouseWheelEvent(mozilla::WidgetWheelEvent& event);
+
+ bool SendRealKeyEvent(mozilla::WidgetKeyboardEvent& event);
+
+ bool SendRealTouchEvent(WidgetTouchEvent& event);
+
+ bool SendHandleTap(TapType aType,
+ const LayoutDevicePoint& aPoint,
+ Modifiers aModifiers,
+ const ScrollableLayerGuid& aGuid,
+ uint64_t aInputBlockId);
+
+ virtual PDocumentRendererParent*
+ AllocPDocumentRendererParent(const nsRect& documentRect,
+ const gfx::Matrix& transform,
+ const nsString& bgcolor,
+ const uint32_t& renderFlags,
+ const bool& flushLayout,
+ const nsIntSize& renderSize) override;
+
+ virtual bool
+ DeallocPDocumentRendererParent(PDocumentRendererParent* actor) override;
+
+ virtual PFilePickerParent*
+ AllocPFilePickerParent(const nsString& aTitle,
+ const int16_t& aMode) override;
+
+ virtual bool DeallocPFilePickerParent(PFilePickerParent* actor) override;
+
+ virtual PIndexedDBPermissionRequestParent*
+ AllocPIndexedDBPermissionRequestParent(const Principal& aPrincipal) override;
+
+ virtual bool
+ RecvPIndexedDBPermissionRequestConstructor(
+ PIndexedDBPermissionRequestParent* aActor,
+ const Principal& aPrincipal)
+ override;
+
+ virtual bool
+ DeallocPIndexedDBPermissionRequestParent(
+ PIndexedDBPermissionRequestParent* aActor)
+ override;
+
+ bool GetGlobalJSObject(JSContext* cx, JSObject** globalp);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIAUTHPROMPTPROVIDER
+ NS_DECL_NSISECUREBROWSERUI
+ NS_DECL_NSIWEBBROWSERPERSISTABLE
+
+ bool HandleQueryContentEvent(mozilla::WidgetQueryContentEvent& aEvent);
+
+ bool SendCompositionEvent(mozilla::WidgetCompositionEvent& event);
+
+ bool SendSelectionEvent(mozilla::WidgetSelectionEvent& event);
+
+ bool SendPasteTransferable(const IPCDataTransfer& aDataTransfer,
+ const bool& aIsPrivateData,
+ const IPC::Principal& aRequestingPrincipal);
+
+ static TabParent* GetFrom(nsFrameLoader* aFrameLoader);
+
+ static TabParent* GetFrom(nsIFrameLoader* aFrameLoader);
+
+ static TabParent* GetFrom(nsITabParent* aTabParent);
+
+ static TabParent* GetFrom(PBrowserParent* aTabParent);
+
+ static TabParent* GetFrom(nsIContent* aContent);
+
+ static TabId GetTabIdFrom(nsIDocShell* docshell);
+
+ nsIContentParent* Manager() const { return mManager; }
+
+ /**
+ * Let managees query if Destroy() is already called so they don't send out
+ * messages when the PBrowser actor is being destroyed.
+ */
+ bool IsDestroyed() const { return mIsDestroyed; }
+
+ already_AddRefed<nsIWidget> GetWidget() const;
+
+ const TabId GetTabId() const
+ {
+ return mTabId;
+ }
+
+ LayoutDeviceIntPoint GetChildProcessOffset();
+ LayoutDevicePoint AdjustTapToChildWidget(const LayoutDevicePoint& aPoint);
+
+ /**
+ * Native widget remoting protocol for use with windowed plugins with e10s.
+ */
+ virtual PPluginWidgetParent* AllocPPluginWidgetParent() override;
+
+ virtual bool
+ DeallocPPluginWidgetParent(PPluginWidgetParent* aActor) override;
+
+ void SetInitedByParent() { mInitedByParent = true; }
+
+ bool IsInitedByParent() const { return mInitedByParent; }
+
+ static TabParent* GetNextTabParent();
+
+ bool SendLoadRemoteScript(const nsString& aURL,
+ const bool& aRunInGlobalScope);
+
+ void LayerTreeUpdate(uint64_t aEpoch, bool aActive);
+
+ virtual bool
+ RecvInvokeDragSession(nsTArray<IPCDataTransfer>&& aTransfers,
+ const uint32_t& aAction,
+ const OptionalShmem& aVisualDnDData,
+ const uint32_t& aStride, const uint8_t& aFormat,
+ const LayoutDeviceIntRect& aDragRect) override;
+
+ void AddInitialDnDDataTo(DataTransfer* aDataTransfer);
+
+ bool TakeDragVisualization(RefPtr<mozilla::gfx::SourceSurface>& aSurface,
+ LayoutDeviceIntRect* aDragRect);
+
+ layout::RenderFrameParent* GetRenderFrame();
+
+ void AudioChannelChangeNotification(nsPIDOMWindowOuter* aWindow,
+ AudioChannel aAudioChannel,
+ float aVolume,
+ bool aMuted);
+ bool SetRenderFrame(PRenderFrameParent* aRFParent);
+ bool GetRenderFrameInfo(TextureFactoryIdentifier* aTextureFactoryIdentifier,
+ uint64_t* aLayersId);
+
+ bool RecvEnsureLayersConnected() override;
+
+protected:
+ bool ReceiveMessage(const nsString& aMessage,
+ bool aSync,
+ ipc::StructuredCloneData* aData,
+ mozilla::jsipc::CpowHolder* aCpows,
+ nsIPrincipal* aPrincipal,
+ nsTArray<ipc::StructuredCloneData>* aJSONRetVal = nullptr);
+
+ virtual bool RecvAsyncAuthPrompt(const nsCString& aUri,
+ const nsString& aRealm,
+ const uint64_t& aCallbackId) override;
+
+ virtual bool Recv__delete__() override;
+
+ virtual void ActorDestroy(ActorDestroyReason why) override;
+
+ Element* mFrameElement;
+ nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow;
+
+ virtual PRenderFrameParent* AllocPRenderFrameParent() override;
+
+ virtual bool DeallocPRenderFrameParent(PRenderFrameParent* aFrame) override;
+
+ virtual bool RecvRemotePaintIsReady() override;
+
+ virtual bool RecvForcePaintNoOp(const uint64_t& aLayerObserverEpoch) override;
+
+ virtual bool RecvSetDimensions(const uint32_t& aFlags,
+ const int32_t& aX, const int32_t& aY,
+ const int32_t& aCx, const int32_t& aCy) override;
+
+ virtual bool RecvGetTabCount(uint32_t* aValue) override;
+
+ virtual bool RecvAudioChannelActivityNotification(const uint32_t& aAudioChannel,
+ const bool& aActive) override;
+
+ virtual bool RecvNotifySessionHistoryChange(const uint32_t& aCount) override;
+
+ virtual bool RecvRequestCrossBrowserNavigation(const uint32_t& aGlobalIndex) override;
+
+ ContentCacheInParent mContentCache;
+
+ nsIntRect mRect;
+ ScreenIntSize mDimensions;
+ ScreenOrientationInternal mOrientation;
+ float mDPI;
+ int32_t mRounding;
+ CSSToLayoutDeviceScale mDefaultScale;
+ bool mUpdatedDimensions;
+ nsSizeMode mSizeMode;
+ LayoutDeviceIntPoint mClientOffset;
+ LayoutDeviceIntPoint mChromeOffset;
+
+private:
+ void DestroyInternal();
+
+ already_AddRefed<nsFrameLoader>
+ GetFrameLoader(bool aUseCachedFrameLoaderAfterDestroy = false) const;
+
+ RefPtr<nsIContentParent> mManager;
+ void TryCacheDPIAndScale();
+
+ nsresult UpdatePosition();
+
+ bool AsyncPanZoomEnabled() const;
+
+ // Cached value indicating the docshell active state of the remote browser.
+ bool mDocShellIsActive;
+
+ // Update state prior to routing an APZ-aware event to the child process.
+ // |aOutTargetGuid| will contain the identifier
+ // of the APZC instance that handled the event. aOutTargetGuid may be null.
+ // |aOutInputBlockId| will contain the identifier of the input block
+ // that this event was added to, if there was one. aOutInputBlockId may be null.
+ // |aOutApzResponse| will contain the response that the APZ gave when processing
+ // the input block; this is used for generating appropriate pointercancel events.
+ void ApzAwareEventRoutingToChild(ScrollableLayerGuid* aOutTargetGuid,
+ uint64_t* aOutInputBlockId,
+ nsEventStatus* aOutApzResponse);
+
+ // When true, we've initiated normal shutdown and notified our managing PContent.
+ bool mMarkedDestroying;
+ // When true, the TabParent is invalid and we should not send IPC messages anymore.
+ bool mIsDestroyed;
+
+ uint32_t mChromeFlags;
+
+ nsTArray<nsTArray<IPCDataTransferItem>> mInitialDataTransferItems;
+
+ RefPtr<gfx::DataSourceSurface> mDnDVisualization;
+ bool mDragValid;
+ LayoutDeviceIntRect mDragRect;
+
+ // When true, the TabParent is initialized without child side's request.
+ // When false, the TabParent is initialized by window.open() from child side.
+ bool mInitedByParent;
+
+ nsCOMPtr<nsILoadContext> mLoadContext;
+
+ // We keep a strong reference to the frameloader after we've sent the
+ // Destroy message and before we've received __delete__. This allows us to
+ // dispatch message manager messages during this time.
+ RefPtr<nsFrameLoader> mFrameLoader;
+
+ TabId mTabId;
+
+ // When loading a new tab or window via window.open, the child process sends
+ // a new PBrowser to use. We store that tab in sNextTabParent and then
+ // proceed through the browser's normal paths to create a new
+ // window/tab. When it comes time to create a new TabParent, we instead use
+ // sNextTabParent.
+ static TabParent* sNextTabParent;
+
+ // When loading a new tab or window via window.open, the child is
+ // responsible for loading the URL it wants into the new TabChild. When the
+ // parent receives the CreateWindow message, though, it sends a LoadURL
+ // message, usually for about:blank. It's important for the about:blank load
+ // to get processed because the Firefox frontend expects every new window to
+ // immediately start loading something (see bug 1123090). However, we want
+ // the child to process the LoadURL message before it returns from
+ // ProvideWindow so that the URL sent from the parent doesn't override the
+ // child's URL. This is not possible using our IPC mechanisms. To solve the
+ // problem, we skip sending the LoadURL message in the parent and instead
+ // return the URL as a result from CreateWindow. The child simulates
+ // receiving a LoadURL message before returning from ProvideWindow.
+ //
+ // The mCreatingWindow flag is set while dispatching CreateWindow. During
+ // that time, any LoadURL calls are skipped and the URL is stored in
+ // mSkippedURL.
+ bool mCreatingWindow;
+ nsCString mDelayedURL;
+
+ // When loading a new tab or window via window.open, we want to ensure that
+ // frame scripts for that tab are loaded before any scripts start to run in
+ // the window. We can't load the frame scripts the normal way, using
+ // separate IPC messages, since they won't be processed by the child until
+ // returning to the event loop, which is too late. Instead, we queue up
+ // frame scripts that we intend to load and send them as part of the
+ // CreateWindow response. Then TabChild loads them immediately.
+ nsTArray<FrameScriptInfo> mDelayedFrameScripts;
+
+ // Cached cursor setting from TabChild. When the cursor is over the tab,
+ // it should take this appearance.
+ nsCursor mCursor;
+ nsCOMPtr<imgIContainer> mCustomCursor;
+ uint32_t mCustomCursorHotspotX, mCustomCursorHotspotY;
+
+ // True if the cursor changes from the TabChild should change the widget
+ // cursor. This happens whenever the cursor is in the tab's region.
+ bool mTabSetsCursor;
+
+ RefPtr<nsIPresShell> mPresShellWithRefreshListener;
+
+ bool mHasContentOpener;
+
+#ifdef DEBUG
+ int32_t mActiveSupressDisplayportCount;
+#endif
+
+ ShowInfo GetShowInfo();
+
+private:
+ // This is used when APZ needs to find the TabParent associated with a layer
+ // to dispatch events.
+ typedef nsDataHashtable<nsUint64HashKey, TabParent*> LayerToTabParentTable;
+ static LayerToTabParentTable* sLayerToTabParentTable;
+
+ static void AddTabParentToTable(uint64_t aLayersId, TabParent* aTabParent);
+
+ static void RemoveTabParentFromTable(uint64_t aLayersId);
+
+ uint64_t mLayerTreeEpoch;
+
+ // If this flag is set, then the tab's layers will be preserved even when
+ // the tab's docshell is inactive.
+ bool mPreserveLayers;
+
+public:
+ static TabParent* GetTabParentFromLayersId(uint64_t aLayersId);
+};
+
+struct MOZ_STACK_CLASS TabParent::AutoUseNewTab final
+{
+public:
+ AutoUseNewTab(TabParent* aNewTab, bool* aWindowIsNew, nsCString* aURLToLoad)
+ : mNewTab(aNewTab), mWindowIsNew(aWindowIsNew), mURLToLoad(aURLToLoad)
+ {
+ MOZ_ASSERT(!TabParent::sNextTabParent);
+ MOZ_ASSERT(!aNewTab->mCreatingWindow);
+
+ TabParent::sNextTabParent = aNewTab;
+ aNewTab->mCreatingWindow = true;
+ aNewTab->mDelayedURL.Truncate();
+ }
+
+ ~AutoUseNewTab()
+ {
+ mNewTab->mCreatingWindow = false;
+ *mURLToLoad = mNewTab->mDelayedURL;
+
+ if (TabParent::sNextTabParent) {
+ MOZ_ASSERT(TabParent::sNextTabParent == mNewTab);
+ TabParent::sNextTabParent = nullptr;
+ *mWindowIsNew = false;
+ }
+ }
+
+private:
+ TabParent* mNewTab;
+ bool* mWindowIsNew;
+ nsCString* mURLToLoad;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_tabs_TabParent_h