dom/ipc/BrowserChild.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_BrowserChild_h
   8 #define mozilla_dom_BrowserChild_h
   9
  10 #include "mozilla/dom/ContentFrameMessageManager.h"
  11 #include "mozilla/dom/PBrowserChild.h"
  12 #include "nsIWebNavigation.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsIWebBrowserChrome.h"
  15 #include "nsIEmbeddingSiteWindow.h"
  16 #include "nsIWebBrowserChromeFocus.h"
  17 #include "nsIDOMEventListener.h"
  18 #include "nsIInterfaceRequestor.h"
  19 #include "nsIWindowProvider.h"
  20 #include "nsIDocShell.h"
  21 #include "nsIInterfaceRequestorUtils.h"
  22 #include "nsFrameMessageManager.h"
  23 #include "nsWeakReference.h"
  24 #include "nsIBrowserChild.h"
  25 #include "nsITooltipListener.h"
  26 #include "nsIWebProgressListener.h"
  27 #include "nsIWebProgressListener2.h"
  28 #include "mozilla/Attributes.h"
  29 #include "mozilla/dom/TabContext.h"
  30 #include "mozilla/dom/CoalescedMouseData.h"
  31 #include "mozilla/dom/CoalescedWheelData.h"
  32 #include "mozilla/DOMEventTargetHelper.h"
  33 #include "mozilla/EventDispatcher.h"
  34 #include "mozilla/EventForwards.h"
  35 #include "mozilla/layers/CompositorTypes.h"
  36 #include "mozilla/layers/APZCCallbackHelper.h"
  37 #include "mozilla/layers/CompositorOptions.h"
  38 #include "mozilla/layers/GeckoContentControllerTypes.h"
  39 #include "nsIWebBrowserChrome3.h"
  40 #include "mozilla/dom/ipc/IdType.h"
  41 #include "AudioChannelService.h"
  42 #include "PuppetWidget.h"
  43 #include "nsDeque.h"
  44
  45 class nsBrowserStatusFilter;
  46 class nsIDOMWindow;
  47 class nsIHttpChannel;
  48 class nsIRequest;
  49 class nsISerialEventTarget;
  50 class nsIWebProgress;
  51 class nsWebBrowser;
  52
  53 template <typename T>
  54 class nsTHashtable;
  55 template <typename T>
  56 class nsPtrHashKey;
  57
  58 namespace mozilla {
  59 class AbstractThread;
  60 class PresShell;
  61
  62 namespace layers {
  63 class APZChild;
  64 class APZEventState;
  65 class AsyncDragMetrics;
  66 class IAPZCTreeManager;
  67 class ImageCompositeNotification;
  68 class PCompositorBridgeChild;
  69 }  // namespace layers
  70
  71 namespace widget {
  72 struct AutoCacheNativeKeyCommands;
  73 }  // namespace widget
  74
  75 namespace dom {
  76
  77 class BrowserChild;
  78 class BrowsingContext;
  79 class TabGroup;
  80 class ClonedMessageData;
  81 class CoalescedMouseData;
  82 class CoalescedWheelData;
  83 class ContentSessionStore;
  84 class TabListener;
  85 class RequestData;
  86 class WebProgressData;
  87
  88 class BrowserChildMessageManager : public ContentFrameMessageManager,
  89                                    public nsIMessageSender,
  90                                    public DispatcherTrait,
  91                                    public nsSupportsWeakReference {
  92  public:
  93   explicit BrowserChildMessageManager(BrowserChild* aBrowserChild);
  94
  95   NS_DECL_ISUPPORTS_INHERITED
  96   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BrowserChildMessageManager,
  97                                            DOMEventTargetHelper)
  98
  99   void MarkForCC();
 100
 101   JSObject* WrapObject(JSContext* aCx,
 102                        JS::Handle<JSObject*> aGivenProto) override;
 103
 104   virtual Nullable<WindowProxyHolder> GetContent(ErrorResult& aError) override;
 105   virtual already_AddRefed<nsIDocShell> GetDocShell(
 106       ErrorResult& aError) override;
 107   virtual already_AddRefed<nsIEventTarget> GetTabEventTarget() override;
 108   virtual uint64_t ChromeOuterWindowID() override;
 109
 110   NS_FORWARD_SAFE_NSIMESSAGESENDER(mMessageManager)
 111
 112   void GetEventTargetParent(EventChainPreVisitor& aVisitor) override {
 113     aVisitor.mForceContentDispatch = true;
 114   }
 115
 116   // Dispatch a runnable related to the global.
 117   virtual nsresult Dispatch(mozilla::TaskCategory aCategory,
 118                             already_AddRefed<nsIRunnable>&& aRunnable) override;
 119
 120   virtual nsISerialEventTarget* EventTargetFor(
 121       mozilla::TaskCategory aCategory) const override;
 122
 123   virtual AbstractThread* AbstractMainThreadFor(
 124       mozilla::TaskCategory aCategory) override;
 125
 126   RefPtr<BrowserChild> mBrowserChild;
 127
 128  protected:
 129   ~BrowserChildMessageManager();
 130 };
 131
 132 class ContentListener final : public nsIDOMEventListener {
 133  public:
 134   explicit ContentListener(BrowserChild* aBrowserChild)
 135       : mBrowserChild(aBrowserChild) {}
 136   NS_DECL_ISUPPORTS
 137   NS_DECL_NSIDOMEVENTLISTENER
 138  protected:
 139   ~ContentListener() = default;
 140   BrowserChild* mBrowserChild;
 141 };
 142
 143 /**
 144  * BrowserChild implements the child actor part of the PBrowser protocol. See
 145  * PBrowser for more information.
 146  */
 147 class BrowserChild final : public nsMessageManagerScriptExecutor,
 148                            public ipc::MessageManagerCallback,
 149                            public PBrowserChild,
 150                            public nsIWebBrowserChrome,
 151                            public nsIEmbeddingSiteWindow,
 152                            public nsIWebBrowserChromeFocus,
 153                            public nsIInterfaceRequestor,
 154                            public nsIWindowProvider,
 155                            public nsSupportsWeakReference,
 156                            public nsIBrowserChild,
 157                            public nsIObserver,
 158                            public nsIWebProgressListener2,
 159                            public TabContext,
 160                            public nsITooltipListener,
 161                            public mozilla::ipc::IShmemAllocator {
 162   typedef mozilla::widget::PuppetWidget PuppetWidget;
 163   typedef mozilla::dom::ClonedMessageData ClonedMessageData;
 164   typedef mozilla::dom::CoalescedMouseData CoalescedMouseData;
 165   typedef mozilla::dom::CoalescedWheelData CoalescedWheelData;
 166   typedef mozilla::layers::APZEventState APZEventState;
 167   typedef mozilla::layers::SetAllowedTouchBehaviorCallback
 168       SetAllowedTouchBehaviorCallback;
 169   typedef mozilla::layers::TouchBehaviorFlags TouchBehaviorFlags;
 170
 171   friend class PBrowserChild;
 172
 173  public:
 174   /**
 175    * Find BrowserChild of aTabId in the same content process of the
 176    * caller.
 177    */
 178   static already_AddRefed<BrowserChild> FindBrowserChild(const TabId& aTabId);
 179
 180   // Return a list of all active BrowserChildren.
 181   static nsTArray<RefPtr<BrowserChild>> GetAll();
 182
 183  public:
 184   /**
 185    * Create a new BrowserChild object.
 186    */
 187   BrowserChild(ContentChild* aManager, const TabId& aTabId,
 188                const TabContext& aContext,
 189                dom::BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
 190                bool aIsTopLevel);
 191
 192   nsresult Init(mozIDOMWindowProxy* aParent,
 193                 WindowGlobalChild* aInitialWindowChild);
 194
 195   /** Return a BrowserChild with the given attributes. */
 196   static already_AddRefed<BrowserChild> Create(
 197       ContentChild* aManager, const TabId& aTabId, const TabContext& aContext,
 198       BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
 199       bool aIsTopLevel);
 200
 201   // Let managees query if it is safe to send messages.
 202   bool IsDestroyed() const { return mDestroyed; }
 203
 204   const TabId GetTabId() const {
 205     MOZ_ASSERT(mUniqueId != 0);
 206     return mUniqueId;
 207   }
 208
 209   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 210   NS_DECL_NSIWEBBROWSERCHROME
 211   NS_DECL_NSIEMBEDDINGSITEWINDOW
 212   NS_DECL_NSIWEBBROWSERCHROMEFOCUS
 213   NS_DECL_NSIINTERFACEREQUESTOR
 214   NS_DECL_NSIWINDOWPROVIDER
 215   NS_DECL_NSIBROWSERCHILD
 216   NS_DECL_NSIOBSERVER
 217   NS_DECL_NSIWEBPROGRESSLISTENER
 218   NS_DECL_NSIWEBPROGRESSLISTENER2
 219   NS_DECL_NSITOOLTIPLISTENER
 220
 221   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(BrowserChild,
 222                                                          nsIBrowserChild)
 223
 224   FORWARD_SHMEM_ALLOCATOR_TO(PBrowserChild)
 225
 226   JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
 227     return mBrowserChildMessageManager->WrapObject(aCx, aGivenProto);
 228   }
 229
 230   // Get the Document for the top-level window in this tab.
 231   already_AddRefed<Document> GetTopLevelDocument() const;
 232
 233   // Get the pres-shell of the document for the top-level window in this tab.
 234   PresShell* GetTopLevelPresShell() const;
 235
 236   BrowserChildMessageManager* GetMessageManager() {
 237     return mBrowserChildMessageManager;
 238   }
 239
 240   bool IsTopLevel() const { return mIsTopLevel; }
 241
 242   /**
 243    * MessageManagerCallback methods that we override.
 244    */
 245   virtual bool DoSendBlockingMessage(
 246       const nsAString& aMessage, StructuredCloneData& aData,
 247       nsTArray<StructuredCloneData>* aRetVal) override;
 248
 249   virtual nsresult DoSendAsyncMessage(const nsAString& aMessage,
 250                                       StructuredCloneData& aData) override;
 251
 252   bool DoUpdateZoomConstraints(const uint32_t& aPresShellId,
 253                                const ViewID& aViewId,
 254                                const Maybe<ZoomConstraints>& aConstraints);
 255
 256   mozilla::ipc::IPCResult RecvLoadURL(const nsCString& aURI,
 257                                       const ParentShowInfo&);
 258
 259   mozilla::ipc::IPCResult RecvResumeLoad(const uint64_t& aPendingSwitchID,
 260                                          const ParentShowInfo&);
 261
 262   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 263   mozilla::ipc::IPCResult RecvShow(const ParentShowInfo&, const OwnerShowInfo&);
 264
 265   mozilla::ipc::IPCResult RecvInitRendering(
 266       const TextureFactoryIdentifier& aTextureFactoryIdentifier,
 267       const layers::LayersId& aLayersId,
 268       const mozilla::layers::CompositorOptions& aCompositorOptions,
 269       const bool& aLayersConnected);
 270
 271   mozilla::ipc::IPCResult RecvCompositorOptionsChanged(
 272       const mozilla::layers::CompositorOptions& aNewOptions);
 273
 274   mozilla::ipc::IPCResult RecvUpdateDimensions(
 275       const mozilla::dom::DimensionInfo& aDimensionInfo);
 276   mozilla::ipc::IPCResult RecvSizeModeChanged(const nsSizeMode& aSizeMode);
 277
 278   mozilla::ipc::IPCResult RecvChildToParentMatrix(
 279       const mozilla::Maybe<mozilla::gfx::Matrix4x4>& aMatrix,
 280       const mozilla::ScreenRect& aTopLevelViewportVisibleRectInBrowserCoords);
 281
 282   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 283   mozilla::ipc::IPCResult RecvDynamicToolbarMaxHeightChanged(
 284       const mozilla::ScreenIntCoord& aHeight);
 285
 286   mozilla::ipc::IPCResult RecvDynamicToolbarOffsetChanged(
 287       const mozilla::ScreenIntCoord& aOffset);
 288
 289   mozilla::ipc::IPCResult RecvActivate();
 290
 291   mozilla::ipc::IPCResult RecvDeactivate();
 292
 293   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 294   mozilla::ipc::IPCResult RecvMouseEvent(const nsString& aType, const float& aX,
 295                                          const float& aY,
 296                                          const int32_t& aButton,
 297                                          const int32_t& aClickCount,
 298                                          const int32_t& aModifiers);
 299
 300   mozilla::ipc::IPCResult RecvRealMouseMoveEvent(
 301       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 302       const uint64_t& aInputBlockId);
 303
 304   mozilla::ipc::IPCResult RecvNormalPriorityRealMouseMoveEvent(
 305       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 306       const uint64_t& aInputBlockId);
 307
 308   mozilla::ipc::IPCResult RecvSynthMouseMoveEvent(
 309       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 310       const uint64_t& aInputBlockId);
 311   mozilla::ipc::IPCResult RecvNormalPrioritySynthMouseMoveEvent(
 312       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 313       const uint64_t& aInputBlockId);
 314
 315   mozilla::ipc::IPCResult RecvRealMouseButtonEvent(
 316       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 317       const uint64_t& aInputBlockId);
 318   mozilla::ipc::IPCResult RecvNormalPriorityRealMouseButtonEvent(
 319       const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
 320       const uint64_t& aInputBlockId);
 321
 322   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 323   mozilla::ipc::IPCResult RecvRealDragEvent(const WidgetDragEvent& aEvent,
 324                                             const uint32_t& aDragAction,
 325                                             const uint32_t& aDropEffect,
 326                                             nsIPrincipal* aPrincipal,
 327                                             nsIContentSecurityPolicy* aCsp);
 328
 329   mozilla::ipc::IPCResult RecvRealKeyEvent(
 330       const mozilla::WidgetKeyboardEvent& aEvent);
 331
 332   mozilla::ipc::IPCResult RecvNormalPriorityRealKeyEvent(
 333       const mozilla::WidgetKeyboardEvent& aEvent);
 334
 335   mozilla::ipc::IPCResult RecvMouseWheelEvent(
 336       const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
 337       const uint64_t& aInputBlockId);
 338
 339   mozilla::ipc::IPCResult RecvNormalPriorityMouseWheelEvent(
 340       const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
 341       const uint64_t& aInputBlockId);
 342
 343   mozilla::ipc::IPCResult RecvRealTouchEvent(const WidgetTouchEvent& aEvent,
 344                                              const ScrollableLayerGuid& aGuid,
 345                                              const uint64_t& aInputBlockId,
 346                                              const nsEventStatus& aApzResponse);
 347
 348   mozilla::ipc::IPCResult RecvNormalPriorityRealTouchEvent(
 349       const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
 350       const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
 351
 352   mozilla::ipc::IPCResult RecvRealTouchMoveEvent(
 353       const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
 354       const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
 355
 356   mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent(
 357       const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
 358       const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
 359
 360   mozilla::ipc::IPCResult RecvRealTouchMoveEvent2(
 361       const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
 362       const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
 363     return RecvRealTouchMoveEvent(aEvent, aGuid, aInputBlockId, aApzResponse);
 364   }
 365
 366   mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent2(
 367       const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
 368       const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
 369     return RecvNormalPriorityRealTouchMoveEvent(aEvent, aGuid, aInputBlockId,
 370                                                 aApzResponse);
 371   }
 372
 373   mozilla::ipc::IPCResult RecvFlushTabState(const uint32_t& aFlushId,
 374                                             const bool& aIsFinal);
 375
 376   mozilla::ipc::IPCResult RecvUpdateEpoch(const uint32_t& aEpoch);
 377
 378   mozilla::ipc::IPCResult RecvUpdateSHistory(const bool& aImmediately);
 379
 380   mozilla::ipc::IPCResult RecvNativeSynthesisResponse(
 381       const uint64_t& aObserverId, const nsCString& aResponse);
 382
 383   mozilla::ipc::IPCResult RecvPluginEvent(const WidgetPluginEvent& aEvent);
 384
 385   mozilla::ipc::IPCResult RecvCompositionEvent(
 386       const mozilla::WidgetCompositionEvent& aEvent);
 387
 388   mozilla::ipc::IPCResult RecvNormalPriorityCompositionEvent(
 389       const mozilla::WidgetCompositionEvent& aEvent);
 390
 391   mozilla::ipc::IPCResult RecvSelectionEvent(
 392       const mozilla::WidgetSelectionEvent& aEvent);
 393
 394   mozilla::ipc::IPCResult RecvNormalPrioritySelectionEvent(
 395       const mozilla::WidgetSelectionEvent& aEvent);
 396
 397   mozilla::ipc::IPCResult RecvSetIsUnderHiddenEmbedderElement(
 398       const bool& aIsUnderHiddenEmbedderElement);
 399
 400   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 401   mozilla::ipc::IPCResult RecvPasteTransferable(
 402       const IPCDataTransfer& aDataTransfer, const bool& aIsPrivateData,
 403       nsIPrincipal* aRequestingPrincipal, const uint32_t& aContentPolicyType);
 404
 405   mozilla::ipc::IPCResult RecvActivateFrameEvent(const nsString& aType,
 406                                                  const bool& aCapture);
 407
 408   mozilla::ipc::IPCResult RecvLoadRemoteScript(const nsString& aURL,
 409                                                const bool& aRunInGlobalScope);
 410
 411   mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMessage,
 412                                            const ClonedMessageData& aData);
 413   mozilla::ipc::IPCResult RecvSwappedWithOtherRemoteLoader(
 414       const IPCTabContext& aContext);
 415
 416   mozilla::ipc::IPCResult RecvSafeAreaInsetsChanged(
 417       const mozilla::ScreenIntMargin& aSafeAreaInsets);
 418
 419 #ifdef ACCESSIBILITY
 420   PDocAccessibleChild* AllocPDocAccessibleChild(PDocAccessibleChild*,
 421                                                 const uint64_t&,
 422                                                 const uint32_t&,
 423                                                 const IAccessibleHolder&);
 424   bool DeallocPDocAccessibleChild(PDocAccessibleChild*);
 425 #endif
 426
 427   PColorPickerChild* AllocPColorPickerChild(const nsString& aTitle,
 428                                             const nsString& aInitialColor);
 429
 430   bool DeallocPColorPickerChild(PColorPickerChild* aActor);
 431
 432   PFilePickerChild* AllocPFilePickerChild(const nsString& aTitle,
 433                                           const int16_t& aMode);
 434
 435   bool DeallocPFilePickerChild(PFilePickerChild* aActor);
 436
 437   nsIWebNavigation* WebNavigation() const { return mWebNav; }
 438
 439   PuppetWidget* WebWidget() { return mPuppetWidget; }
 440
 441   bool IsTransparent() const { return mIsTransparent; }
 442
 443   const EffectsInfo& GetEffectsInfo() const { return mEffectsInfo; }
 444
 445   hal::ScreenOrientation GetOrientation() const { return mOrientation; }
 446
 447   void SetBackgroundColor(const nscolor& aColor);
 448
 449   void NotifyPainted();
 450
 451   MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual mozilla::ipc::IPCResult RecvUpdateEffects(
 452       const EffectsInfo& aEffects);
 453
 454   void RequestEditCommands(nsIWidget::NativeKeyBindingsType aType,
 455                            const WidgetKeyboardEvent& aEvent,
 456                            nsTArray<CommandInt>& aCommands);
 457
 458   bool IsVisible();
 459
 460   /**
 461    * Signal to this BrowserChild that it should be made visible:
 462    * activated widget, retained layer tree, etc.  (Respectively,
 463    * made not visible.)
 464    */
 465   MOZ_CAN_RUN_SCRIPT void UpdateVisibility();
 466   MOZ_CAN_RUN_SCRIPT void MakeVisible();
 467   void MakeHidden();
 468
 469   ContentChild* Manager() const { return mManager; }
 470
 471   static inline BrowserChild* GetFrom(nsIDocShell* aDocShell) {
 472     if (!aDocShell) {
 473       return nullptr;
 474     }
 475
 476     nsCOMPtr<nsIBrowserChild> tc = aDocShell->GetBrowserChild();
 477     return static_cast<BrowserChild*>(tc.get());
 478   }
 479
 480   static inline BrowserChild* GetFrom(mozIDOMWindow* aWindow) {
 481     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
 482     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
 483     return GetFrom(docShell);
 484   }
 485
 486   static inline BrowserChild* GetFrom(mozIDOMWindowProxy* aWindow) {
 487     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
 488     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
 489     return GetFrom(docShell);
 490   }
 491
 492   static BrowserChild* GetFrom(PresShell* aPresShell);
 493   static BrowserChild* GetFrom(layers::LayersId aLayersId);
 494
 495   layers::LayersId GetLayersId() { return mLayersId; }
 496   Maybe<bool> IsLayersConnected() { return mLayersConnected; }
 497
 498   void DidComposite(mozilla::layers::TransactionId aTransactionId,
 499                     const TimeStamp& aCompositeStart,
 500                     const TimeStamp& aCompositeEnd);
 501
 502   void DidRequestComposite(const TimeStamp& aCompositeReqStart,
 503                            const TimeStamp& aCompositeReqEnd);
 504
 505   void ClearCachedResources();
 506   void InvalidateLayers();
 507   void SchedulePaint();
 508   void ReinitRendering();
 509   void ReinitRenderingForDeviceReset();
 510
 511   static inline BrowserChild* GetFrom(nsIDOMWindow* aWindow) {
 512     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
 513     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
 514     return GetFrom(docShell);
 515   }
 516
 517   mozilla::ipc::IPCResult RecvUIResolutionChanged(const float& aDpi,
 518                                                   const int32_t& aRounding,
 519                                                   const double& aScale);
 520
 521   mozilla::ipc::IPCResult RecvThemeChanged(
 522       nsTArray<LookAndFeelInt>&& aLookAndFeelIntCache);
 523
 524   mozilla::ipc::IPCResult RecvHandleAccessKey(const WidgetKeyboardEvent& aEvent,
 525                                               nsTArray<uint32_t>&& aCharCodes);
 526
 527   mozilla::ipc::IPCResult RecvHandledWindowedPluginKeyEvent(
 528       const mozilla::NativeEventData& aKeyEventData, const bool& aIsConsumed);
 529
 530   mozilla::ipc::IPCResult RecvPrint(const uint64_t& aOuterWindowID,
 531                                     const PrintData& aPrintData);
 532
 533   mozilla::ipc::IPCResult RecvUpdateNativeWindowHandle(
 534       const uintptr_t& aNewHandle);
 535
 536   mozilla::ipc::IPCResult RecvWillChangeProcess(
 537       WillChangeProcessResolver&& aResolve);
 538   /**
 539    * Native widget remoting protocol for use with windowed plugins with e10s.
 540    */
 541   PPluginWidgetChild* AllocPPluginWidgetChild();
 542
 543   bool DeallocPPluginWidgetChild(PPluginWidgetChild* aActor);
 544
 545 #ifdef XP_WIN
 546   nsresult CreatePluginWidget(nsIWidget* aParent, nsIWidget** aOut);
 547 #endif
 548
 549   PPaymentRequestChild* AllocPPaymentRequestChild();
 550
 551   bool DeallocPPaymentRequestChild(PPaymentRequestChild* aActor);
 552
 553   LayoutDeviceIntPoint GetClientOffset() const { return mClientOffset; }
 554   LayoutDeviceIntPoint GetChromeOffset() const { return mChromeOffset; };
 555   ScreenIntCoord GetDynamicToolbarMaxHeight() const {
 556     return mDynamicToolbarMaxHeight;
 557   };
 558
 559   bool IPCOpen() const { return mIPCOpen; }
 560
 561   bool ParentIsActive() const { return mParentIsActive; }
 562
 563   const mozilla::layers::CompositorOptions& GetCompositorOptions() const;
 564   bool AsyncPanZoomEnabled() const;
 565
 566   ScreenIntSize GetInnerSize();
 567   CSSSize GetUnscaledInnerSize() { return mUnscaledInnerSize; }
 568
 569   Maybe<LayoutDeviceIntRect> GetVisibleRect() const;
 570
 571   // Call RecvShow(nsIntSize(0, 0)) and block future calls to RecvShow().
 572   void DoFakeShow(const ParentShowInfo&);
 573
 574   void ContentReceivedInputBlock(uint64_t aInputBlockId,
 575                                  bool aPreventDefault) const;
 576   void SetTargetAPZC(
 577       uint64_t aInputBlockId,
 578       const nsTArray<layers::ScrollableLayerGuid>& aTargets) const;
 579   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 580   mozilla::ipc::IPCResult RecvHandleTap(
 581       const layers::GeckoContentController_TapType& aType,
 582       const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
 583       const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
 584
 585   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 586   mozilla::ipc::IPCResult RecvNormalPriorityHandleTap(
 587       const layers::GeckoContentController_TapType& aType,
 588       const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
 589       const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
 590
 591   void SetAllowedTouchBehavior(
 592       uint64_t aInputBlockId, const nsTArray<TouchBehaviorFlags>& aFlags) const;
 593
 594   bool UpdateFrame(const layers::RepaintRequest& aRequest);
 595   bool NotifyAPZStateChange(
 596       const ViewID& aViewId,
 597       const layers::GeckoContentController_APZStateChange& aChange,
 598       const int& aArg);
 599   void StartScrollbarDrag(const layers::AsyncDragMetrics& aDragMetrics);
 600   void ZoomToRect(const uint32_t& aPresShellId,
 601                   const ScrollableLayerGuid::ViewID& aViewId,
 602                   const CSSRect& aRect, const uint32_t& aFlags);
 603
 604   // Request that the docshell be marked as active.
 605   void PaintWhileInterruptingJS(const layers::LayersObserverEpoch& aEpoch);
 606
 607   nsresult CanCancelContentJS(nsIRemoteTab::NavigationType aNavigationType,
 608                               int32_t aNavigationIndex, nsIURI* aNavigationURI,
 609                               int32_t aEpoch, bool* aCanCancel);
 610
 611   layers::LayersObserverEpoch LayersObserverEpoch() const {
 612     return mLayersObserverEpoch;
 613   }
 614
 615 #if defined(XP_WIN) && defined(ACCESSIBILITY)
 616   uintptr_t GetNativeWindowHandle() const { return mNativeWindowHandle; }
 617 #endif
 618
 619   // These methods return `true` if this BrowserChild is currently awaiting a
 620   // Large-Allocation header.
 621   bool StopAwaitingLargeAlloc();
 622   bool IsAwaitingLargeAlloc();
 623
 624   BrowsingContext* GetBrowsingContext() const { return mBrowsingContext; }
 625
 626 #if defined(ACCESSIBILITY)
 627   void SetTopLevelDocAccessibleChild(PDocAccessibleChild* aTopLevelChild) {
 628     mTopLevelDocAccessibleChild = aTopLevelChild;
 629   }
 630
 631   PDocAccessibleChild* GetTopLevelDocAccessibleChild() {
 632     return mTopLevelDocAccessibleChild;
 633   }
 634 #endif
 635
 636   void AddPendingDocShellBlocker();
 637   void RemovePendingDocShellBlocker();
 638
 639   // The HANDLE object for the widget this BrowserChild in.
 640   WindowsHandle WidgetNativeData() { return mWidgetNativeData; }
 641
 642   // The transform from the coordinate space of this BrowserChild to the
 643   // coordinate space of the native window its BrowserParent is in.
 644   mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
 645   GetChildToParentConversionMatrix() const;
 646
 647   // Returns the portion of the visible rect of this remote document in the
 648   // top browser window coordinate system.  This is the result of being clipped
 649   // by all ancestor viewports.
 650   mozilla::ScreenRect GetTopLevelViewportVisibleRectInBrowserCoords() const;
 651
 652   // Similar to above GetTopLevelViewportVisibleRectInBrowserCoords(), but in
 653   // this out-of-process document's coordinate system.
 654   Maybe<LayoutDeviceRect> GetTopLevelViewportVisibleRectInSelfCoords() const;
 655
 656   // Prepare to dispatch all coalesced mousemove events. We'll move all data
 657   // in mCoalescedMouseData to a nsDeque; then we start processing them. We
 658   // can't fetch the coalesced event one by one and dispatch it because we may
 659   // reentry the event loop and access to the same hashtable. It's called when
 660   // dispatching some mouse events other than mousemove.
 661   void FlushAllCoalescedMouseData();
 662   void ProcessPendingCoalescedMouseDataAndDispatchEvents();
 663
 664   void HandleRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
 665                                   const ScrollableLayerGuid& aGuid,
 666                                   const uint64_t& aInputBlockId);
 667
 668   void SetCancelContentJSEpoch(int32_t aEpoch) {
 669     mCancelContentJSEpoch = aEpoch;
 670   }
 671
 672   static bool HasVisibleTabs() {
 673     return sVisibleTabs && !sVisibleTabs->IsEmpty();
 674   }
 675
 676   // Returns the set of BrowserChilds that are currently rendering layers. There
 677   // can be multiple BrowserChilds in this state if Firefox has multiple windows
 678   // open or is warming tabs up. There can also be zero BrowserChilds in this
 679   // state. Note that this function should only be called if HasVisibleTabs()
 680   // returns true.
 681   static const nsTHashtable<nsPtrHashKey<BrowserChild>>& GetVisibleTabs() {
 682     MOZ_ASSERT(HasVisibleTabs());
 683     return *sVisibleTabs;
 684   }
 685
 686   bool UpdateSessionStore(uint32_t aFlushId, bool aIsFinal = false);
 687
 688 #ifdef XP_WIN
 689   // Check if the window this BrowserChild is associated with supports
 690   // protected media (EME) or not.
 691   // Returns a promise the will resolve true if the window supports protected
 692   // media or false if it does not. The promise will be rejected with an
 693   // ResponseRejectReason if the IPC needed to do the check fails. Callers
 694   // should treat the reject case as if the window does not support protected
 695   // media to ensure robust handling.
 696   RefPtr<IsWindowSupportingProtectedMediaPromise>
 697   DoesWindowSupportProtectedMedia();
 698 #endif
 699
 700   // Notify the content blocking event in the parent process. This sends an IPC
 701   // message to the BrowserParent in the parent. The BrowserParent will find the
 702   // top-level WindowGlobalParent and notify the event from it.
 703   void NotifyContentBlockingEvent(
 704       uint32_t aEvent, nsIChannel* aChannel, bool aBlocked,
 705       const nsACString& aTrackingOrigin,
 706       const nsTArray<nsCString>& aTrackingFullHashes,
 707       const Maybe<ContentBlockingNotifier::StorageAccessGrantedReason>&
 708           aReason);
 709
 710  protected:
 711   virtual ~BrowserChild();
 712
 713   mozilla::ipc::IPCResult RecvDestroy();
 714
 715   mozilla::ipc::IPCResult RecvSetDocShellIsActive(const bool& aIsActive);
 716
 717   mozilla::ipc::IPCResult RecvSetSuspendMediaWhenInactive(
 718       const bool& aSuspendMediaWhenInactive);
 719
 720   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 721   mozilla::ipc::IPCResult RecvRenderLayers(
 722       const bool& aEnabled, const layers::LayersObserverEpoch& aEpoch);
 723
 724   mozilla::ipc::IPCResult RecvNavigateByKey(const bool& aForward,
 725                                             const bool& aForDocumentNavigation);
 726
 727   mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint();
 728
 729   mozilla::ipc::IPCResult RecvSuppressDisplayport(const bool& aEnabled);
 730
 731   mozilla::ipc::IPCResult RecvParentActivated(const bool& aActivated);
 732
 733   mozilla::ipc::IPCResult RecvScrollbarPreferenceChanged(ScrollbarPreference);
 734
 735   mozilla::ipc::IPCResult RecvSetKeyboardIndicators(
 736       const UIStateChangeType& aShowFocusRings);
 737
 738   mozilla::ipc::IPCResult RecvStopIMEStateManagement();
 739
 740   mozilla::ipc::IPCResult RecvAwaitLargeAlloc();
 741
 742   mozilla::ipc::IPCResult RecvAllowScriptsToClose();
 743
 744   mozilla::ipc::IPCResult RecvSetWidgetNativeData(
 745       const WindowsHandle& aWidgetNativeData);
 746
 747  private:
 748   // Wraps up a JSON object as a structured clone and sends it to the browser
 749   // chrome script.
 750   //
 751   // XXX/bug 780335: Do the work the browser chrome script does in C++ instead
 752   // so we don't need things like this.
 753   void DispatchMessageManagerMessage(const nsAString& aMessageName,
 754                                      const nsAString& aJSONData);
 755
 756   void ProcessUpdateFrame(const mozilla::layers::RepaintRequest& aRequest);
 757
 758   bool UpdateFrameHandler(const mozilla::layers::RepaintRequest& aRequest);
 759
 760   void HandleDoubleTap(const CSSPoint& aPoint, const Modifiers& aModifiers,
 761                        const ScrollableLayerGuid& aGuid);
 762
 763   // Notify others that our TabContext has been updated.
 764   //
 765   // You should call this after calling TabContext::SetTabContext().  We also
 766   // call this during Init().
 767   void NotifyTabContextUpdated();
 768
 769   void ActorDestroy(ActorDestroyReason why) override;
 770
 771   bool InitBrowserChildMessageManager();
 772
 773   void InitRenderingState(
 774       const TextureFactoryIdentifier& aTextureFactoryIdentifier,
 775       const layers::LayersId& aLayersId,
 776       const mozilla::layers::CompositorOptions& aCompositorOptions);
 777   void InitAPZState();
 778
 779   void DestroyWindow();
 780
 781   void ApplyParentShowInfo(const ParentShowInfo&);
 782
 783   bool HasValidInnerSize();
 784
 785   void SetTabId(const TabId& aTabId);
 786
 787   ScreenIntRect GetOuterRect();
 788
 789   void SetUnscaledInnerSize(const CSSSize& aSize) {
 790     mUnscaledInnerSize = aSize;
 791   }
 792
 793   bool SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent);
 794
 795   void UpdateRepeatedKeyEventEndTime(const WidgetKeyboardEvent& aEvent);
 796
 797   bool MaybeCoalesceWheelEvent(const WidgetWheelEvent& aEvent,
 798                                const ScrollableLayerGuid& aGuid,
 799                                const uint64_t& aInputBlockId,
 800                                bool* aIsNextWheelEvent);
 801
 802   void MaybeDispatchCoalescedWheelEvent();
 803
 804   /**
 805    * Dispatch aEvent on aEvent.mWidget.
 806    */
 807   nsEventStatus DispatchWidgetEventViaAPZ(WidgetGUIEvent& aEvent);
 808
 809   void DispatchWheelEvent(const WidgetWheelEvent& aEvent,
 810                           const ScrollableLayerGuid& aGuid,
 811                           const uint64_t& aInputBlockId);
 812
 813   void InternalSetDocShellIsActive(bool aIsActive);
 814
 815   void InternalSetSuspendMediaWhenInactive(bool aSuspendMediaWhenInactive);
 816
 817   bool CreateRemoteLayerManager(
 818       mozilla::layers::PCompositorBridgeChild* aCompositorChild);
 819
 820   nsresult PrepareProgressListenerData(nsIWebProgress* aWebProgress,
 821                                        nsIRequest* aRequest,
 822                                        Maybe<WebProgressData>& aWebProgressData,
 823                                        RequestData& aRequestData);
 824   already_AddRefed<nsIWebBrowserChrome3> GetWebBrowserChromeActor();
 825
 826   class DelayedDeleteRunnable;
 827
 828   RefPtr<BrowserChildMessageManager> mBrowserChildMessageManager;
 829   nsCOMPtr<nsIWebBrowserChrome3> mWebBrowserChrome;
 830   TextureFactoryIdentifier mTextureFactoryIdentifier;
 831   RefPtr<nsWebBrowser> mWebBrowser;
 832   nsCOMPtr<nsIWebNavigation> mWebNav;
 833   RefPtr<PuppetWidget> mPuppetWidget;
 834   nsCOMPtr<nsIURI> mLastURI;
 835   RefPtr<ContentChild> mManager;
 836   RefPtr<BrowsingContext> mBrowsingContext;
 837   RefPtr<nsBrowserStatusFilter> mStatusFilter;
 838   uint32_t mChromeFlags;
 839   uint32_t mMaxTouchPoints;
 840   layers::LayersId mLayersId;
 841   CSSRect mUnscaledOuterRect;
 842   Maybe<bool> mLayersConnected;
 843   EffectsInfo mEffectsInfo;
 844   bool mDidFakeShow;
 845   bool mNotified;
 846   bool mTriedBrowserInit;
 847   hal::ScreenOrientation mOrientation;
 848
 849   bool mIgnoreKeyPressEvent;
 850   RefPtr<APZEventState> mAPZEventState;
 851   SetAllowedTouchBehaviorCallback mSetAllowedTouchBehaviorCallback;
 852   bool mHasValidInnerSize;
 853   bool mDestroyed;
 854
 855   // Position of client area relative to the outer window
 856   LayoutDeviceIntPoint mClientOffset;
 857   // Position of tab, relative to parent widget (typically the window)
 858   LayoutDeviceIntPoint mChromeOffset;
 859   ScreenIntCoord mDynamicToolbarMaxHeight;
 860   TabId mUniqueId;
 861
 862   // Whether or not this browser is the child part of the top level PBrowser
 863   // actor in a remote browser.
 864   bool mIsTopLevel;
 865
 866   // Whether or not this tab has siblings (other tabs in the same window).
 867   // This is one factor used when choosing to allow or deny a non-system
 868   // script's attempt to resize the window.
 869   bool mHasSiblings;
 870
 871   // Holds the compositor options for the compositor rendering this tab,
 872   // once we find out which compositor that is.
 873   Maybe<mozilla::layers::CompositorOptions> mCompositorOptions;
 874
 875   friend class ContentChild;
 876
 877   bool mIsTransparent;
 878
 879   bool mIPCOpen;
 880   bool mParentIsActive;
 881   CSSSize mUnscaledInnerSize;
 882   bool mDidSetRealShowInfo;
 883   bool mDidLoadURLInit;
 884   bool mAwaitingLA;
 885
 886   bool mSkipKeyPress;
 887
 888   // Store the end time of the handling of the last repeated keydown/keypress
 889   // event so that in case event handling takes time, some repeated events can
 890   // be skipped to not flood child process.
 891   mozilla::TimeStamp mRepeatedKeyEventTime;
 892
 893   // Similar to mRepeatedKeyEventTime, store the end time (from parent process)
 894   // of handling the last repeated wheel event so that in case event handling
 895   // takes time, some repeated events can be skipped to not flood child process.
 896   mozilla::TimeStamp mLastWheelProcessedTimeFromParent;
 897   mozilla::TimeDuration mLastWheelProcessingDuration;
 898
 899   // Hash table to track coalesced mousemove events for different pointers.
 900   nsClassHashtable<nsUint32HashKey, CoalescedMouseData> mCoalescedMouseData;
 901
 902   nsDeque mToBeDispatchedMouseData;
 903
 904   CoalescedWheelData mCoalescedWheelData;
 905   RefPtr<CoalescedMouseMoveFlusher> mCoalescedMouseEventFlusher;
 906
 907   RefPtr<layers::IAPZCTreeManager> mApzcTreeManager;
 908   RefPtr<TabListener> mSessionStoreListener;
 909
 910   // The most recently seen layer observer epoch in RecvSetDocShellIsActive.
 911   layers::LayersObserverEpoch mLayersObserverEpoch;
 912
 913 #if defined(XP_WIN) && defined(ACCESSIBILITY)
 914   // The handle associated with the native window that contains this tab
 915   uintptr_t mNativeWindowHandle;
 916 #endif  // defined(XP_WIN)
 917
 918 #if defined(ACCESSIBILITY)
 919   PDocAccessibleChild* mTopLevelDocAccessibleChild;
 920 #endif
 921   bool mCoalesceMouseMoveEvents;
 922
 923   bool mShouldSendWebProgressEventsToParent;
 924
 925   // Whether we are rendering to the compositor or not.
 926   bool mRenderLayers;
 927
 928   // In some circumstances, a DocShell might be in a state where it is
 929   // "blocked", and we should not attempt to change its active state or
 930   // the underlying PresShell state until the DocShell becomes unblocked.
 931   // It is possible, however, for the parent process to send commands to
 932   // change those states while the DocShell is blocked. We store those
 933   // states temporarily as "pending", and only apply them once the DocShell
 934   // is no longer blocked.
 935   bool mPendingDocShellIsActive;
 936   bool mPendingSuspendMediaWhenInactive;
 937   bool mPendingDocShellReceivedMessage;
 938   bool mPendingRenderLayers;
 939   bool mPendingRenderLayersReceivedMessage;
 940   layers::LayersObserverEpoch mPendingLayersObserverEpoch;
 941   // When mPendingDocShellBlockers is greater than 0, the DocShell is blocked,
 942   // and once it reaches 0, it is no longer blocked.
 943   uint32_t mPendingDocShellBlockers;
 944   int32_t mCancelContentJSEpoch;
 945
 946   WindowsHandle mWidgetNativeData;
 947
 948   Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> mChildToParentConversionMatrix;
 949   ScreenRect mTopLevelViewportVisibleRectInBrowserCoords;
 950
 951 #ifdef XP_WIN
 952   // Should only be accessed on main thread.
 953   Maybe<bool> mWindowSupportsProtectedMedia;
 954 #endif
 955
 956   // This state is used to keep track of the current visible tabs (the ones
 957   // rendering layers). There may be more than one if there are multiple browser
 958   // windows open, or tabs are being warmed up. There may be none if this
 959   // process does not host any visible or warming tabs.
 960   static nsTHashtable<nsPtrHashKey<BrowserChild>>* sVisibleTabs;
 961
 962   DISALLOW_EVIL_CONSTRUCTORS(BrowserChild);
 963 };
 964
 965 }  // namespace dom
 966 }  // namespace mozilla
 967
 968 #endif  // mozilla_dom_BrowserChild_h