mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 17:25:36 +00:00
c0756f3389
Backed out changeset 644ceb2fe568 (bug1523638) Backed out changeset 27647ee7a927 (bug1523638) Backed out changeset 96f1ccb95570 (bug1523638) Backed out changeset b60a17ea716a (bug1523638) Backed out changeset 507e63186c5f (bug1523638) Backed out changeset 33255408ca61 (bug1523638) Backed out changeset d97b2d223616 (bug1523638) Backed out changeset eba2a0514cde (bug1523638) Backed out changeset d7065174c5c4 (bug1523638) Backed out changeset c21b361e175d (bug1523638)
928 lines
34 KiB
C++
928 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 "nsAutoPtr.h"
|
|
#include "nsIWebBrowserChrome2.h"
|
|
#include "nsIEmbeddingSiteWindow.h"
|
|
#include "nsIWebBrowserChromeFocus.h"
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsIWindowProvider.h"
|
|
#include "nsIDOMWindow.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsFrameMessageManager.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/CoalescedWheelData.h"
|
|
#include "mozilla/DOMEventTargetHelper.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventForwards.h"
|
|
#include "mozilla/layers/CompositorTypes.h"
|
|
#include "mozilla/layers/APZCCallbackHelper.h"
|
|
#include "mozilla/layers/CompositorOptions.h"
|
|
#include "nsIWebBrowserChrome3.h"
|
|
#include "mozilla/dom/ipc/IdType.h"
|
|
#include "AudioChannelService.h"
|
|
#include "PuppetWidget.h"
|
|
#include "mozilla/layers/GeckoContentController.h"
|
|
#include "nsDeque.h"
|
|
#include "nsISHistoryListener.h"
|
|
|
|
class nsBrowserStatusFilter;
|
|
class nsIDOMWindowUtils;
|
|
class nsIHttpChannel;
|
|
class nsIRequest;
|
|
class nsISerialEventTarget;
|
|
class nsIWebProgress;
|
|
class nsWebBrowser;
|
|
|
|
template <typename T>
|
|
class nsTHashtable;
|
|
template <typename T>
|
|
class nsPtrHashKey;
|
|
|
|
namespace mozilla {
|
|
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 TabGroup;
|
|
class ClonedMessageData;
|
|
class CoalescedMouseData;
|
|
class CoalescedWheelData;
|
|
class ContentSessionStore;
|
|
class TabListener;
|
|
class RequestData;
|
|
class WebProgressData;
|
|
|
|
class BrowserChildMessageManager : public ContentFrameMessageManager,
|
|
public nsIMessageSender,
|
|
public DispatcherTrait,
|
|
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;
|
|
|
|
virtual Nullable<WindowProxyHolder> GetContent(ErrorResult& aError) override;
|
|
virtual already_AddRefed<nsIDocShell> GetDocShell(
|
|
ErrorResult& aError) override;
|
|
virtual already_AddRefed<nsIEventTarget> GetTabEventTarget() override;
|
|
virtual uint64_t ChromeOuterWindowID() override;
|
|
|
|
NS_FORWARD_SAFE_NSIMESSAGESENDER(mMessageManager)
|
|
|
|
void GetEventTargetParent(EventChainPreVisitor& aVisitor) override {
|
|
aVisitor.mForceContentDispatch = true;
|
|
}
|
|
|
|
// Dispatch a runnable related to the global.
|
|
virtual nsresult Dispatch(mozilla::TaskCategory aCategory,
|
|
already_AddRefed<nsIRunnable>&& aRunnable) override;
|
|
|
|
virtual nsISerialEventTarget* EventTargetFor(
|
|
mozilla::TaskCategory aCategory) const override;
|
|
|
|
virtual AbstractThread* AbstractMainThreadFor(
|
|
mozilla::TaskCategory aCategory) override;
|
|
|
|
RefPtr<BrowserChild> mBrowserChild;
|
|
|
|
protected:
|
|
~BrowserChildMessageManager();
|
|
};
|
|
|
|
class ContentListener final : public nsIDOMEventListener {
|
|
public:
|
|
explicit ContentListener(BrowserChild* aBrowserChild)
|
|
: mBrowserChild(aBrowserChild) {}
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIDOMEVENTLISTENER
|
|
protected:
|
|
~ContentListener() {}
|
|
BrowserChild* mBrowserChild;
|
|
};
|
|
|
|
/**
|
|
* 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 nsIWebBrowserChrome2,
|
|
public nsIEmbeddingSiteWindow,
|
|
public nsIWebBrowserChromeFocus,
|
|
public nsIInterfaceRequestor,
|
|
public nsIWindowProvider,
|
|
public nsSupportsWeakReference,
|
|
public nsIBrowserChild,
|
|
public nsIObserver,
|
|
public nsIWebProgressListener2,
|
|
public TabContext,
|
|
public nsITooltipListener,
|
|
public mozilla::ipc::IShmemAllocator {
|
|
typedef mozilla::widget::PuppetWidget PuppetWidget;
|
|
typedef mozilla::dom::ClonedMessageData ClonedMessageData;
|
|
typedef mozilla::dom::CoalescedMouseData CoalescedMouseData;
|
|
typedef mozilla::dom::CoalescedWheelData CoalescedWheelData;
|
|
typedef mozilla::layers::APZEventState APZEventState;
|
|
typedef mozilla::layers::SetAllowedTouchBehaviorCallback
|
|
SetAllowedTouchBehaviorCallback;
|
|
typedef mozilla::layers::TouchBehaviorFlags 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, TabGroup* aTabGroup,
|
|
const TabContext& aContext, BrowsingContext* aBrowsingContext,
|
|
uint32_t aChromeFlags, bool aIsTopLevel);
|
|
|
|
nsresult Init(mozIDOMWindowProxy* aParent);
|
|
|
|
/** Return a BrowserChild with the given attributes. */
|
|
static already_AddRefed<BrowserChild> Create(
|
|
ContentChild* aManager, const TabId& aTabId, const TabId& aSameTabGroupAs,
|
|
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; }
|
|
|
|
const TabId GetTabId() const {
|
|
MOZ_ASSERT(mUniqueId != 0);
|
|
return mUniqueId;
|
|
}
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_NSIWEBBROWSERCHROME
|
|
NS_DECL_NSIWEBBROWSERCHROME2
|
|
NS_DECL_NSIEMBEDDINGSITEWINDOW
|
|
NS_DECL_NSIWEBBROWSERCHROMEFOCUS
|
|
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);
|
|
}
|
|
|
|
nsIPrincipal* GetPrincipal() { return mPrincipal; }
|
|
// 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; }
|
|
|
|
/**
|
|
* MessageManagerCallback methods that we override.
|
|
*/
|
|
virtual bool DoSendBlockingMessage(JSContext* aCx, const nsAString& aMessage,
|
|
StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows,
|
|
nsIPrincipal* aPrincipal,
|
|
nsTArray<StructuredCloneData>* aRetVal,
|
|
bool aIsSync) override;
|
|
|
|
virtual nsresult DoSendAsyncMessage(JSContext* aCx, const nsAString& aMessage,
|
|
StructuredCloneData& aData,
|
|
JS::Handle<JSObject*> aCpows,
|
|
nsIPrincipal* aPrincipal) override;
|
|
|
|
bool DoUpdateZoomConstraints(const uint32_t& aPresShellId,
|
|
const ViewID& aViewId,
|
|
const Maybe<ZoomConstraints>& aConstraints);
|
|
|
|
mozilla::ipc::IPCResult RecvLoadURL(const nsCString& aURI,
|
|
const ShowInfo& aInfo);
|
|
|
|
mozilla::ipc::IPCResult RecvResumeLoad(const uint64_t& aPendingSwitchID,
|
|
const ShowInfo& aInfo);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvShow(const ScreenIntSize& aSize,
|
|
const ShowInfo& aInfo,
|
|
const bool& aParentIsActive,
|
|
const nsSizeMode& aSizeMode);
|
|
|
|
mozilla::ipc::IPCResult RecvInitRendering(
|
|
const TextureFactoryIdentifier& aTextureFactoryIdentifier,
|
|
const layers::LayersId& aLayersId,
|
|
const mozilla::layers::CompositorOptions& aCompositorOptions,
|
|
const bool& aLayersConnected);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateDimensions(
|
|
const mozilla::dom::DimensionInfo& aDimensionInfo);
|
|
mozilla::ipc::IPCResult RecvSizeModeChanged(const nsSizeMode& aSizeMode);
|
|
|
|
mozilla::ipc::IPCResult RecvChildToParentMatrix(
|
|
const mozilla::gfx::Matrix4x4& aMatrix);
|
|
|
|
mozilla::ipc::IPCResult RecvActivate();
|
|
|
|
mozilla::ipc::IPCResult RecvDeactivate();
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvMouseEvent(const nsString& aType, const float& aX,
|
|
const float& aY,
|
|
const int32_t& aButton,
|
|
const int32_t& aClickCount,
|
|
const int32_t& aModifiers,
|
|
const bool& aIgnoreRootScrollFrame);
|
|
|
|
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 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);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvRealDragEvent(const WidgetDragEvent& aEvent,
|
|
const uint32_t& aDragAction,
|
|
const uint32_t& aDropEffect,
|
|
nsIPrincipal* aPrincipal);
|
|
|
|
mozilla::ipc::IPCResult RecvRealKeyEvent(
|
|
const mozilla::WidgetKeyboardEvent& aEvent);
|
|
|
|
mozilla::ipc::IPCResult RecvNormalPriorityRealKeyEvent(
|
|
const mozilla::WidgetKeyboardEvent& aEvent);
|
|
|
|
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 RecvFlushTabState(const uint32_t& aFlushId,
|
|
const bool& aIsFinal);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateEpoch(const uint32_t& aEpoch);
|
|
|
|
mozilla::ipc::IPCResult RecvNativeSynthesisResponse(
|
|
const uint64_t& aObserverId, const nsCString& aResponse);
|
|
|
|
mozilla::ipc::IPCResult RecvPluginEvent(const WidgetPluginEvent& aEvent);
|
|
|
|
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 RecvSetIsUnderHiddenEmbedderElement(
|
|
const bool& aIsUnderHiddenEmbedderElement);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvPasteTransferable(
|
|
const IPCDataTransfer& aDataTransfer, const bool& aIsPrivateData,
|
|
nsIPrincipal* aRequestingPrincipal, const uint32_t& aContentPolicyType);
|
|
|
|
mozilla::ipc::IPCResult RecvActivateFrameEvent(const nsString& aType,
|
|
const bool& aCapture);
|
|
|
|
mozilla::ipc::IPCResult RecvLoadRemoteScript(const nsString& aURL,
|
|
const bool& aRunInGlobalScope);
|
|
|
|
mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMessage,
|
|
nsTArray<CpowEntry>&& aCpows,
|
|
nsIPrincipal* aPrincipal,
|
|
const ClonedMessageData& aData);
|
|
mozilla::ipc::IPCResult RecvSwappedWithOtherRemoteLoader(
|
|
const IPCTabContext& aContext);
|
|
|
|
PDocAccessibleChild* AllocPDocAccessibleChild(PDocAccessibleChild*,
|
|
const uint64_t&,
|
|
const uint32_t&,
|
|
const IAccessibleHolder&);
|
|
|
|
bool DeallocPDocAccessibleChild(PDocAccessibleChild*);
|
|
|
|
PColorPickerChild* AllocPColorPickerChild(const nsString& aTitle,
|
|
const nsString& aInitialColor);
|
|
|
|
bool DeallocPColorPickerChild(PColorPickerChild* aActor);
|
|
|
|
PFilePickerChild* AllocPFilePickerChild(const nsString& aTitle,
|
|
const int16_t& aMode);
|
|
|
|
bool DeallocPFilePickerChild(PFilePickerChild* aActor);
|
|
|
|
nsIWebNavigation* WebNavigation() const { return mWebNav; }
|
|
|
|
PuppetWidget* WebWidget() { return mPuppetWidget; }
|
|
|
|
bool IsTransparent() const { return mIsTransparent; }
|
|
|
|
const EffectsInfo& GetEffectsInfo() const { return mEffectsInfo; }
|
|
|
|
hal::ScreenOrientation GetOrientation() const { return mOrientation; }
|
|
|
|
void SetBackgroundColor(const nscolor& aColor);
|
|
|
|
void NotifyPainted();
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual mozilla::ipc::IPCResult RecvUpdateEffects(
|
|
const EffectsInfo& aEffects);
|
|
|
|
void RequestEditCommands(nsIWidget::NativeKeyBindingsType aType,
|
|
const WidgetKeyboardEvent& aEvent,
|
|
nsTArray<CommandInt>& aCommands);
|
|
|
|
bool IsVisible();
|
|
|
|
/**
|
|
* Signal to this BrowserChild that it should be made visible:
|
|
* activated widget, retained layer tree, etc. (Respectively,
|
|
* made not visible.)
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void UpdateVisibility(bool aForceRepaint);
|
|
MOZ_CAN_RUN_SCRIPT void MakeVisible(bool aForceRepaint);
|
|
void MakeHidden();
|
|
|
|
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 DidRequestComposite(const TimeStamp& aCompositeReqStart,
|
|
const TimeStamp& aCompositeReqEnd);
|
|
|
|
void ClearCachedResources();
|
|
void InvalidateLayers();
|
|
void SchedulePaint();
|
|
void ReinitRendering();
|
|
void ReinitRenderingForDeviceReset();
|
|
|
|
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 RecvThemeChanged(
|
|
nsTArray<LookAndFeelInt>&& aLookAndFeelIntCache);
|
|
|
|
mozilla::ipc::IPCResult RecvHandleAccessKey(const WidgetKeyboardEvent& aEvent,
|
|
nsTArray<uint32_t>&& aCharCodes);
|
|
|
|
mozilla::ipc::IPCResult RecvSetUseGlobalHistory(const bool& aUse);
|
|
|
|
mozilla::ipc::IPCResult RecvHandledWindowedPluginKeyEvent(
|
|
const mozilla::NativeEventData& aKeyEventData, const bool& aIsConsumed);
|
|
|
|
mozilla::ipc::IPCResult RecvPrint(const uint64_t& aOuterWindowID,
|
|
const PrintData& aPrintData);
|
|
|
|
mozilla::ipc::IPCResult RecvUpdateNativeWindowHandle(
|
|
const uintptr_t& aNewHandle);
|
|
|
|
mozilla::ipc::IPCResult RecvSkipBrowsingContextDetach();
|
|
/**
|
|
* Native widget remoting protocol for use with windowed plugins with e10s.
|
|
*/
|
|
PPluginWidgetChild* AllocPPluginWidgetChild();
|
|
|
|
bool DeallocPPluginWidgetChild(PPluginWidgetChild* aActor);
|
|
|
|
#ifdef XP_WIN
|
|
nsresult CreatePluginWidget(nsIWidget* aParent, nsIWidget** aOut);
|
|
#endif
|
|
|
|
PPaymentRequestChild* AllocPPaymentRequestChild();
|
|
|
|
bool DeallocPPaymentRequestChild(PPaymentRequestChild* aActor);
|
|
|
|
LayoutDeviceIntPoint GetClientOffset() const { return mClientOffset; }
|
|
LayoutDeviceIntPoint GetChromeOffset() const { return mChromeOffset; };
|
|
|
|
bool IPCOpen() const { return mIPCOpen; }
|
|
|
|
bool ParentIsActive() const { return mParentIsActive; }
|
|
|
|
const mozilla::layers::CompositorOptions& GetCompositorOptions() const;
|
|
bool AsyncPanZoomEnabled() const;
|
|
|
|
ScreenIntSize GetInnerSize();
|
|
|
|
Maybe<LayoutDeviceIntRect> GetVisibleRect() const;
|
|
|
|
// Call RecvShow(nsIntSize(0, 0)) and block future calls to RecvShow().
|
|
void DoFakeShow(const ShowInfo& aShowInfo);
|
|
|
|
void ContentReceivedInputBlock(uint64_t aInputBlockId,
|
|
bool aPreventDefault) const;
|
|
void SetTargetAPZC(
|
|
uint64_t aInputBlockId,
|
|
const nsTArray<layers::SLGuidAndRenderRoot>& 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);
|
|
|
|
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);
|
|
|
|
void SetAllowedTouchBehavior(
|
|
uint64_t aInputBlockId, const nsTArray<TouchBehaviorFlags>& aFlags) const;
|
|
|
|
bool UpdateFrame(const layers::RepaintRequest& aRequest);
|
|
bool NotifyAPZStateChange(
|
|
const ViewID& aViewId,
|
|
const layers::GeckoContentController::APZStateChange& aChange,
|
|
const int& aArg);
|
|
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(const layers::LayersObserverEpoch& aEpoch,
|
|
bool aForceRepaint);
|
|
|
|
nsresult CanCancelContentJS(nsIRemoteTab::NavigationType aNavigationType,
|
|
int32_t aNavigationIndex, nsIURI* aNavigationURI,
|
|
int32_t aEpoch, bool* aCanCancel);
|
|
|
|
layers::LayersObserverEpoch LayersObserverEpoch() const {
|
|
return mLayersObserverEpoch;
|
|
}
|
|
|
|
#if defined(XP_WIN) && defined(ACCESSIBILITY)
|
|
uintptr_t GetNativeWindowHandle() const { return mNativeWindowHandle; }
|
|
#endif
|
|
|
|
// These methods return `true` if this BrowserChild is currently awaiting a
|
|
// Large-Allocation header.
|
|
bool StopAwaitingLargeAlloc();
|
|
bool IsAwaitingLargeAlloc();
|
|
|
|
mozilla::dom::TabGroup* TabGroup();
|
|
|
|
#if defined(ACCESSIBILITY)
|
|
void SetTopLevelDocAccessibleChild(PDocAccessibleChild* aTopLevelChild) {
|
|
mTopLevelDocAccessibleChild = aTopLevelChild;
|
|
}
|
|
|
|
PDocAccessibleChild* GetTopLevelDocAccessibleChild() {
|
|
return mTopLevelDocAccessibleChild;
|
|
}
|
|
#endif
|
|
|
|
void AddPendingDocShellBlocker();
|
|
void RemovePendingDocShellBlocker();
|
|
|
|
// The HANDLE object for the widget this BrowserChild in.
|
|
WindowsHandle WidgetNativeData() { return mWidgetNativeData; }
|
|
|
|
// 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;
|
|
|
|
// 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 HandleRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId);
|
|
|
|
void SetCancelContentJSEpoch(int32_t aEpoch) {
|
|
mCancelContentJSEpoch = aEpoch;
|
|
}
|
|
|
|
static bool HasVisibleTabs() {
|
|
return sVisibleTabs && !sVisibleTabs->IsEmpty();
|
|
}
|
|
|
|
// Returns the set of BrowserChilds that are currently rendering layers. There
|
|
// can be multiple BrowserChilds in this state if Firefox has multiple windows
|
|
// open or is warming tabs up. There can also be zero BrowserChilds in this
|
|
// state. Note that this function should only be called if HasVisibleTabs()
|
|
// returns true.
|
|
static const nsTHashtable<nsPtrHashKey<BrowserChild>>& GetVisibleTabs() {
|
|
MOZ_ASSERT(HasVisibleTabs());
|
|
return *sVisibleTabs;
|
|
}
|
|
|
|
bool UpdateSessionStore(uint32_t aFlushId, bool aIsFinal = false);
|
|
|
|
protected:
|
|
virtual ~BrowserChild();
|
|
|
|
PWindowGlobalChild* AllocPWindowGlobalChild(const WindowGlobalInit& aInit);
|
|
|
|
bool DeallocPWindowGlobalChild(PWindowGlobalChild* aActor);
|
|
|
|
PBrowserBridgeChild* AllocPBrowserBridgeChild(
|
|
const nsString& aName, const nsString& aRemoteType,
|
|
BrowsingContext* aBrowsingContext, const uint32_t& aChromeFlags,
|
|
const TabId& aTabId);
|
|
|
|
bool DeallocPBrowserBridgeChild(PBrowserBridgeChild* aActor);
|
|
|
|
mozilla::ipc::IPCResult RecvDestroy();
|
|
|
|
mozilla::ipc::IPCResult RecvSetDocShellIsActive(const bool& aIsActive);
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
mozilla::ipc::IPCResult RecvRenderLayers(
|
|
const bool& aEnabled, const bool& aForce,
|
|
const layers::LayersObserverEpoch& aEpoch);
|
|
|
|
mozilla::ipc::IPCResult RecvNavigateByKey(const bool& aForward,
|
|
const bool& aForDocumentNavigation);
|
|
|
|
mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint();
|
|
|
|
mozilla::ipc::IPCResult RecvSuppressDisplayport(const bool& aEnabled);
|
|
|
|
mozilla::ipc::IPCResult RecvParentActivated(const bool& aActivated);
|
|
|
|
mozilla::ipc::IPCResult RecvSetKeyboardIndicators(
|
|
const UIStateChangeType& aShowFocusRings);
|
|
|
|
mozilla::ipc::IPCResult RecvStopIMEStateManagement();
|
|
|
|
mozilla::ipc::IPCResult RecvAwaitLargeAlloc();
|
|
|
|
mozilla::ipc::IPCResult RecvSetWindowName(const nsString& aName);
|
|
|
|
mozilla::ipc::IPCResult RecvAllowScriptsToClose();
|
|
|
|
mozilla::ipc::IPCResult RecvSetOriginAttributes(
|
|
const OriginAttributes& aOriginAttributes);
|
|
|
|
mozilla::ipc::IPCResult RecvSetWidgetNativeData(
|
|
const WindowsHandle& aWidgetNativeData);
|
|
|
|
mozilla::ipc::IPCResult RecvGetContentBlockingLog(
|
|
GetContentBlockingLogResolver&& aResolve);
|
|
|
|
private:
|
|
// Wraps up a JSON object as a structured clone and sends it to the browser
|
|
// chrome script.
|
|
//
|
|
// XXX/bug 780335: Do the work the browser chrome script does in C++ instead
|
|
// so we don't need things like this.
|
|
void DispatchMessageManagerMessage(const nsAString& aMessageName,
|
|
const nsAString& aJSONData);
|
|
|
|
void ProcessUpdateFrame(const mozilla::layers::RepaintRequest& aRequest);
|
|
|
|
bool UpdateFrameHandler(const mozilla::layers::RepaintRequest& aRequest);
|
|
|
|
void HandleDoubleTap(const CSSPoint& aPoint, const Modifiers& aModifiers,
|
|
const ScrollableLayerGuid& aGuid);
|
|
|
|
// Notify others that our TabContext has been updated.
|
|
//
|
|
// You should call this after calling TabContext::SetTabContext(). We also
|
|
// call this during Init().
|
|
//
|
|
// @param aIsPreallocated true if this is called for Preallocated Tab.
|
|
void NotifyTabContextUpdated(bool aIsPreallocated);
|
|
|
|
// Update the frameType on our docshell.
|
|
void UpdateFrameType();
|
|
|
|
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 ApplyShowInfo(const ShowInfo& aInfo);
|
|
|
|
bool HasValidInnerSize();
|
|
|
|
void SetTabId(const TabId& aTabId);
|
|
|
|
ScreenIntRect GetOuterRect();
|
|
|
|
void SetUnscaledInnerSize(const CSSSize& aSize) {
|
|
mUnscaledInnerSize = aSize;
|
|
}
|
|
|
|
bool SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent);
|
|
|
|
void UpdateRepeatedKeyEventEndTime(const WidgetKeyboardEvent& aEvent);
|
|
|
|
bool MaybeCoalesceWheelEvent(const WidgetWheelEvent& aEvent,
|
|
const ScrollableLayerGuid& aGuid,
|
|
const uint64_t& aInputBlockId,
|
|
bool* aIsNextWheelEvent);
|
|
|
|
void MaybeDispatchCoalescedWheelEvent();
|
|
|
|
/**
|
|
* 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);
|
|
|
|
bool CreateRemoteLayerManager(
|
|
mozilla::layers::PCompositorBridgeChild* aCompositorChild);
|
|
|
|
nsresult PrepareProgressListenerData(nsIWebProgress* aWebProgress,
|
|
nsIRequest* aRequest,
|
|
Maybe<WebProgressData>& aWebProgressData,
|
|
RequestData& aRequestData);
|
|
|
|
class DelayedDeleteRunnable;
|
|
|
|
RefPtr<BrowserChildMessageManager> mBrowserChildMessageManager;
|
|
nsCOMPtr<nsIWebBrowserChrome3> mWebBrowserChrome;
|
|
TextureFactoryIdentifier mTextureFactoryIdentifier;
|
|
RefPtr<nsWebBrowser> mWebBrowser;
|
|
nsCOMPtr<nsIWebNavigation> mWebNav;
|
|
RefPtr<mozilla::dom::TabGroup> mTabGroup;
|
|
RefPtr<PuppetWidget> mPuppetWidget;
|
|
nsCOMPtr<nsIURI> mLastURI;
|
|
RefPtr<ContentChild> mManager;
|
|
RefPtr<BrowsingContext> mBrowsingContext;
|
|
RefPtr<nsBrowserStatusFilter> mStatusFilter;
|
|
uint32_t mChromeFlags;
|
|
uint32_t mMaxTouchPoints;
|
|
layers::LayersId mLayersId;
|
|
CSSRect mUnscaledOuterRect;
|
|
Maybe<bool> mLayersConnected;
|
|
EffectsInfo mEffectsInfo;
|
|
bool mDidFakeShow;
|
|
bool mNotified;
|
|
bool mTriedBrowserInit;
|
|
hal::ScreenOrientation mOrientation;
|
|
|
|
bool mIgnoreKeyPressEvent;
|
|
RefPtr<APZEventState> mAPZEventState;
|
|
SetAllowedTouchBehaviorCallback mSetAllowedTouchBehaviorCallback;
|
|
bool mHasValidInnerSize;
|
|
bool mDestroyed;
|
|
|
|
// Position of client area relative to the outer window
|
|
LayoutDeviceIntPoint mClientOffset;
|
|
// Position of tab, relative to parent widget (typically the window)
|
|
LayoutDeviceIntPoint mChromeOffset;
|
|
TabId mUniqueId;
|
|
|
|
// Whether or not this browser is the child part of the top level PBrowser
|
|
// actor in a remote browser.
|
|
bool mIsTopLevel;
|
|
|
|
// Whether or not this tab has siblings (other tabs in the same window).
|
|
// This is one factor used when choosing to allow or deny a non-system
|
|
// script's attempt to resize the window.
|
|
bool mHasSiblings;
|
|
|
|
// 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;
|
|
|
|
bool mIsTransparent;
|
|
|
|
bool mIPCOpen;
|
|
bool mParentIsActive;
|
|
CSSSize mUnscaledInnerSize;
|
|
bool mDidSetRealShowInfo;
|
|
bool mDidLoadURLInit;
|
|
bool mAwaitingLA;
|
|
|
|
bool mSkipKeyPress;
|
|
|
|
// 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 mToBeDispatchedMouseData;
|
|
|
|
CoalescedWheelData mCoalescedWheelData;
|
|
RefPtr<CoalescedMouseMoveFlusher> mCoalescedMouseEventFlusher;
|
|
|
|
RefPtr<layers::IAPZCTreeManager> mApzcTreeManager;
|
|
RefPtr<TabListener> mSessionStoreListener;
|
|
|
|
// The most recently seen layer observer epoch in RecvSetDocShellIsActive.
|
|
layers::LayersObserverEpoch mLayersObserverEpoch;
|
|
|
|
#if defined(XP_WIN) && defined(ACCESSIBILITY)
|
|
// The handle associated with the native window that contains this tab
|
|
uintptr_t mNativeWindowHandle;
|
|
#endif // defined(XP_WIN)
|
|
|
|
#if defined(ACCESSIBILITY)
|
|
PDocAccessibleChild* mTopLevelDocAccessibleChild;
|
|
#endif
|
|
bool mCoalesceMouseMoveEvents;
|
|
|
|
bool mShouldSendWebProgressEventsToParent;
|
|
|
|
// Whether we are rendering to the compositor or not.
|
|
bool mRenderLayers;
|
|
|
|
// In some circumstances, a DocShell might be in a state where it is
|
|
// "blocked", and we should not attempt to change its active state or
|
|
// the underlying PresShell state until the DocShell becomes unblocked.
|
|
// It is possible, however, for the parent process to send commands to
|
|
// change those states while the DocShell is blocked. We store those
|
|
// states temporarily as "pending", and only apply them once the DocShell
|
|
// is no longer blocked.
|
|
bool mPendingDocShellIsActive;
|
|
bool mPendingDocShellReceivedMessage;
|
|
bool mPendingRenderLayers;
|
|
bool mPendingRenderLayersReceivedMessage;
|
|
layers::LayersObserverEpoch mPendingLayersObserverEpoch;
|
|
// When mPendingDocShellBlockers is greater than 0, the DocShell is blocked,
|
|
// and once it reaches 0, it is no longer blocked.
|
|
uint32_t mPendingDocShellBlockers;
|
|
int32_t mCancelContentJSEpoch;
|
|
|
|
WindowsHandle mWidgetNativeData;
|
|
|
|
Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> mChildToParentConversionMatrix;
|
|
|
|
// This state is used to keep track of the current visible tabs (the ones
|
|
// rendering layers). There may be more than one if there are multiple browser
|
|
// windows open, or tabs are being warmed up. There may be none if this
|
|
// process does not host any visible or warming tabs.
|
|
static nsTHashtable<nsPtrHashKey<BrowserChild>>* sVisibleTabs;
|
|
|
|
DISALLOW_EVIL_CONSTRUCTORS(BrowserChild);
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_dom_BrowserChild_h
|