widget/PuppetWidget.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=8 et :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 /**
   9  * This "puppet widget" isn't really a platform widget.  It's intended
  10  * to be used in widgetless rendering contexts, such as sandboxed
  11  * content processes.  If any "real" widgetry is needed, the request
  12  * is forwarded to and/or data received from elsewhere.
  13  */
  14
  15 #ifndef mozilla_widget_PuppetWidget_h__
  16 #define mozilla_widget_PuppetWidget_h__
  17
  18 #include "mozilla/gfx/2D.h"
  19 #include "mozilla/RefPtr.h"
  20 #include "nsBaseScreen.h"
  21 #include "nsBaseWidget.h"
  22 #include "nsCOMArray.h"
  23 #include "nsIKeyEventInPluginCallback.h"
  24 #include "nsIScreenManager.h"
  25 #include "nsThreadUtils.h"
  26 #include "mozilla/Attributes.h"
  27 #include "mozilla/ContentCache.h"
  28 #include "mozilla/EventForwards.h"
  29 #include "mozilla/TextEventDispatcherListener.h"
  30 #include "mozilla/layers/MemoryPressureObserver.h"
  31
  32 namespace mozilla {
  33
  34 namespace dom {
  35 class BrowserChild;
  36 }  // namespace dom
  37
  38 namespace widget {
  39
  40 struct AutoCacheNativeKeyCommands;
  41
  42 class PuppetWidget : public nsBaseWidget,
  43                      public TextEventDispatcherListener,
  44                      public layers::MemoryPressureListener {
  45   typedef mozilla::CSSRect CSSRect;
  46   typedef mozilla::dom::BrowserChild BrowserChild;
  47   typedef mozilla::gfx::DrawTarget DrawTarget;
  48
  49   // Avoiding to make compiler confused between mozilla::widget and nsIWidget.
  50   typedef mozilla::widget::TextEventDispatcher TextEventDispatcher;
  51   typedef mozilla::widget::TextEventDispatcherListener
  52       TextEventDispatcherListener;
  53
  54   typedef nsBaseWidget Base;
  55
  56   // The width and height of the "widget" are clamped to this.
  57   static const size_t kMaxDimension;
  58
  59  public:
  60   explicit PuppetWidget(BrowserChild* aBrowserChild);
  61
  62  protected:
  63   virtual ~PuppetWidget();
  64
  65  public:
  66   NS_DECL_ISUPPORTS_INHERITED
  67
  68   // PuppetWidget creation is infallible, hence InfallibleCreate(), which
  69   // Create() calls.
  70   using nsBaseWidget::Create;  // for Create signature not overridden here
  71   virtual nsresult Create(nsIWidget* aParent, nsNativeWidget aNativeParent,
  72                           const LayoutDeviceIntRect& aRect,
  73                           nsWidgetInitData* aInitData = nullptr) override;
  74   void InfallibleCreate(nsIWidget* aParent, nsNativeWidget aNativeParent,
  75                         const LayoutDeviceIntRect& aRect,
  76                         nsWidgetInitData* aInitData = nullptr);
  77
  78   void InitIMEState();
  79
  80   virtual already_AddRefed<nsIWidget> CreateChild(
  81       const LayoutDeviceIntRect& aRect, nsWidgetInitData* aInitData = nullptr,
  82       bool aForceUseIWidgetParent = false) override;
  83
  84   virtual void Destroy() override;
  85
  86   virtual void Show(bool aState) override;
  87
  88   virtual bool IsVisible() const override { return mVisible; }
  89
  90   virtual void ConstrainPosition(bool /*ignored aAllowSlop*/, int32_t* aX,
  91                                  int32_t* aY) override {
  92     *aX = kMaxDimension;
  93     *aY = kMaxDimension;
  94   }
  95
  96   // Widget position is controlled by the parent process via BrowserChild.
  97   virtual void Move(double aX, double aY) override {}
  98
  99   virtual void Resize(double aWidth, double aHeight, bool aRepaint) override;
 100   virtual void Resize(double aX, double aY, double aWidth, double aHeight,
 101                       bool aRepaint) override {
 102     if (!mBounds.IsEqualXY(aX, aY)) {
 103       NotifyWindowMoved(aX, aY);
 104     }
 105     mBounds.MoveTo(aX, aY);
 106     return Resize(aWidth, aHeight, aRepaint);
 107   }
 108
 109   // XXX/cjones: copying gtk behavior here; unclear what disabling a
 110   // widget is supposed to entail
 111   virtual void Enable(bool aState) override { mEnabled = aState; }
 112   virtual bool IsEnabled() const override { return mEnabled; }
 113
 114   virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override;
 115
 116   virtual nsresult ConfigureChildren(
 117       const nsTArray<Configuration>& aConfigurations) override;
 118
 119   virtual void Invalidate(const LayoutDeviceIntRect& aRect) override;
 120
 121   // PuppetWidgets don't have native data, as they're purely nonnative.
 122   virtual void* GetNativeData(uint32_t aDataType) override;
 123 #if defined(XP_WIN)
 124   void SetNativeData(uint32_t aDataType, uintptr_t aVal) override;
 125 #endif
 126
 127   // PuppetWidgets don't have any concept of titles.
 128   virtual nsresult SetTitle(const nsAString& aTitle) override {
 129     return NS_ERROR_UNEXPECTED;
 130   }
 131
 132   virtual mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
 133   WidgetToTopLevelWidgetTransform() override;
 134
 135   virtual LayoutDeviceIntPoint WidgetToScreenOffset() override;
 136
 137   virtual LayoutDeviceIntPoint TopLevelWidgetToScreenOffset() override {
 138     return GetWindowPosition();
 139   }
 140
 141   int32_t RoundsWidgetCoordinatesTo() override;
 142
 143   void InitEvent(WidgetGUIEvent& aEvent,
 144                  LayoutDeviceIntPoint* aPoint = nullptr);
 145
 146   virtual nsresult DispatchEvent(WidgetGUIEvent* aEvent,
 147                                  nsEventStatus& aStatus) override;
 148   nsEventStatus DispatchInputEvent(WidgetInputEvent* aEvent) override;
 149   void SetConfirmedTargetAPZC(
 150       uint64_t aInputBlockId,
 151       const nsTArray<ScrollableLayerGuid>& aTargets) const override;
 152   void UpdateZoomConstraints(
 153       const uint32_t& aPresShellId, const ScrollableLayerGuid::ViewID& aViewId,
 154       const mozilla::Maybe<ZoomConstraints>& aConstraints) override;
 155   bool AsyncPanZoomEnabled() const override;
 156
 157   virtual bool GetEditCommands(
 158       NativeKeyBindingsType aType, const mozilla::WidgetKeyboardEvent& aEvent,
 159       nsTArray<mozilla::CommandInt>& aCommands) override;
 160
 161   friend struct AutoCacheNativeKeyCommands;
 162
 163   //
 164   // nsBaseWidget methods we override
 165   //
 166
 167   // Documents loaded in child processes are always subdocuments of
 168   // other docs in an ancestor process.  To ensure that the
 169   // backgrounds of those documents are painted like those of
 170   // same-process subdocuments, we force the widget here to be
 171   // transparent, which in turn will cause layout to use a transparent
 172   // backstop background color.
 173   virtual nsTransparencyMode GetTransparencyMode() override {
 174     return eTransparencyTransparent;
 175   }
 176
 177   virtual LayerManager* GetLayerManager(
 178       PLayerTransactionChild* aShadowManager = nullptr,
 179       LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
 180       LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
 181
 182   // This is used for creating remote layer managers and for re-creating
 183   // them after a compositor reset. The lambda aInitializeFunc is used to
 184   // perform any caller-required initialization for the newly created layer
 185   // manager; in the event of a failure, return false and it will destroy the
 186   // new layer manager without changing the state of the widget.
 187   bool CreateRemoteLayerManager(
 188       const std::function<bool(LayerManager*)>& aInitializeFunc);
 189
 190   bool HasLayerManager() { return !!mLayerManager; }
 191
 192   virtual void SetInputContext(const InputContext& aContext,
 193                                const InputContextAction& aAction) override;
 194   virtual InputContext GetInputContext() override;
 195   virtual NativeIMEContext GetNativeIMEContext() override;
 196   TextEventDispatcherListener* GetNativeTextEventDispatcherListener() override {
 197     return mNativeTextEventDispatcherListener
 198                ? mNativeTextEventDispatcherListener.get()
 199                : this;
 200   }
 201   void SetNativeTextEventDispatcherListener(
 202       TextEventDispatcherListener* aListener) {
 203     mNativeTextEventDispatcherListener = aListener;
 204   }
 205
 206   virtual void SetCursor(nsCursor aDefaultCursor, imgIContainer* aCustomCursor,
 207                          uint32_t aHotspotX, uint32_t aHotspotY) override;
 208
 209   virtual void ClearCachedCursor() override;
 210
 211   // Gets the DPI of the screen corresponding to this widget.
 212   // Contacts the parent process which gets the DPI from the
 213   // proper widget there. TODO: Handle DPI changes that happen
 214   // later on.
 215   virtual float GetDPI() override;
 216   virtual double GetDefaultScaleInternal() override;
 217
 218   virtual bool NeedsPaint() override;
 219
 220   // Paint the widget immediately if any paints are queued up.
 221   void PaintNowIfNeeded();
 222
 223   virtual BrowserChild* GetOwningBrowserChild() override {
 224     return mBrowserChild;
 225   }
 226
 227   void UpdateBackingScaleCache(float aDpi, int32_t aRounding, double aScale) {
 228     mDPI = aDpi;
 229     mRounding = aRounding;
 230     mDefaultScale = aScale;
 231   }
 232
 233   nsIntSize GetScreenDimensions();
 234
 235   // safe area insets support
 236   virtual ScreenIntMargin GetSafeAreaInsets() const override;
 237   void UpdateSafeAreaInsets(const ScreenIntMargin& aSafeAreaInsets);
 238
 239   // Get the offset to the chrome of the window that this tab belongs to.
 240   //
 241   // NOTE: In OOP iframes this value is zero. You should use
 242   // WidgetToTopLevelWidgetTransform instead which is already including the
 243   // chrome offset.
 244   LayoutDeviceIntPoint GetChromeOffset();
 245
 246   // Get the screen position of the application window.
 247   LayoutDeviceIntPoint GetWindowPosition();
 248
 249   virtual LayoutDeviceIntRect GetScreenBounds() override;
 250
 251   virtual LayoutDeviceIntSize GetCompositionSize() override;
 252
 253   [[nodiscard]] virtual nsresult StartPluginIME(
 254       const mozilla::WidgetKeyboardEvent& aKeyboardEvent, int32_t aPanelX,
 255       int32_t aPanelY, nsString& aCommitted) override;
 256
 257   virtual void SetPluginFocused(bool& aFocused) override;
 258   virtual void DefaultProcOfPluginEvent(
 259       const mozilla::WidgetPluginEvent& aEvent) override;
 260
 261   virtual nsresult SynthesizeNativeKeyEvent(
 262       int32_t aNativeKeyboardLayout, int32_t aNativeKeyCode,
 263       uint32_t aModifierFlags, const nsAString& aCharacters,
 264       const nsAString& aUnmodifiedCharacters, nsIObserver* aObserver) override;
 265   virtual nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
 266                                               uint32_t aNativeMessage,
 267                                               uint32_t aModifierFlags,
 268                                               nsIObserver* aObserver) override;
 269   virtual nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
 270                                              nsIObserver* aObserver) override;
 271   virtual nsresult SynthesizeNativeMouseScrollEvent(
 272       LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, double aDeltaX,
 273       double aDeltaY, double aDeltaZ, uint32_t aModifierFlags,
 274       uint32_t aAdditionalFlags, nsIObserver* aObserver) override;
 275   virtual nsresult SynthesizeNativeTouchPoint(uint32_t aPointerId,
 276                                               TouchPointerState aPointerState,
 277                                               LayoutDeviceIntPoint aPoint,
 278                                               double aPointerPressure,
 279                                               uint32_t aPointerOrientation,
 280                                               nsIObserver* aObserver) override;
 281   virtual nsresult SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
 282                                             bool aLongTap,
 283                                             nsIObserver* aObserver) override;
 284   virtual nsresult ClearNativeTouchSequence(nsIObserver* aObserver) override;
 285   virtual uint32_t GetMaxTouchPoints() const override;
 286
 287   virtual void StartAsyncScrollbarDrag(
 288       const AsyncDragMetrics& aDragMetrics) override;
 289
 290   virtual void SetCandidateWindowForPlugin(
 291       const CandidateWindowPosition& aPosition) override;
 292   virtual void EnableIMEForPlugin(bool aEnable) override;
 293
 294   virtual void ZoomToRect(const uint32_t& aPresShellId,
 295                           const ScrollableLayerGuid::ViewID& aViewId,
 296                           const CSSRect& aRect,
 297                           const uint32_t& aFlags) override;
 298
 299   virtual bool HasPendingInputEvent() override;
 300
 301   void HandledWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
 302                                      bool aIsConsumed);
 303
 304   virtual nsresult OnWindowedPluginKeyEvent(
 305       const NativeEventData& aKeyEventData,
 306       nsIKeyEventInPluginCallback* aCallback) override;
 307
 308   virtual void LookUpDictionary(
 309       const nsAString& aText,
 310       const nsTArray<mozilla::FontRange>& aFontRangeArray,
 311       const bool aIsVertical, const LayoutDeviceIntPoint& aPoint) override;
 312
 313   nsresult SetSystemFont(const nsCString& aFontName) override;
 314   nsresult GetSystemFont(nsCString& aFontName) override;
 315
 316   nsresult SetPrefersReducedMotionOverrideForTest(bool aValue) override;
 317   nsresult ResetPrefersReducedMotionOverrideForTest() override;
 318
 319   // TextEventDispatcherListener
 320   using nsBaseWidget::NotifyIME;
 321   NS_IMETHOD NotifyIME(TextEventDispatcher* aTextEventDispatcher,
 322                        const IMENotification& aNotification) override;
 323   NS_IMETHOD_(IMENotificationRequests) GetIMENotificationRequests() override;
 324   NS_IMETHOD_(void)
 325   OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher) override;
 326   NS_IMETHOD_(void)
 327   WillDispatchKeyboardEvent(TextEventDispatcher* aTextEventDispatcher,
 328                             WidgetKeyboardEvent& aKeyboardEvent,
 329                             uint32_t aIndexOfKeypress, void* aData) override;
 330
 331   virtual void OnMemoryPressure(layers::MemoryPressureReason aWhy) override;
 332
 333  private:
 334   nsresult Paint();
 335
 336   void SetChild(PuppetWidget* aChild);
 337
 338   nsresult RequestIMEToCommitComposition(bool aCancel);
 339   nsresult NotifyIMEOfFocusChange(const IMENotification& aIMENotification);
 340   nsresult NotifyIMEOfSelectionChange(const IMENotification& aIMENotification);
 341   nsresult NotifyIMEOfCompositionUpdate(
 342       const IMENotification& aIMENotification);
 343   nsresult NotifyIMEOfTextChange(const IMENotification& aIMENotification);
 344   nsresult NotifyIMEOfMouseButtonEvent(const IMENotification& aIMENotification);
 345   nsresult NotifyIMEOfPositionChange(const IMENotification& aIMENotification);
 346
 347   bool CacheEditorRect();
 348   bool CacheCompositionRects(uint32_t& aStartOffset,
 349                              nsTArray<LayoutDeviceIntRect>& aRectArray,
 350                              uint32_t& aTargetCauseOffset);
 351   bool GetCaretRect(LayoutDeviceIntRect& aCaretRect, uint32_t aCaretOffset);
 352   uint32_t GetCaretOffset();
 353
 354   nsIWidgetListener* GetCurrentWidgetListener();
 355
 356   // When this widget caches input context and currently managed by
 357   // IMEStateManager, the cache is valid.
 358   bool HaveValidInputContextCache() const;
 359
 360   class PaintTask : public Runnable {
 361    public:
 362     NS_DECL_NSIRUNNABLE
 363     explicit PaintTask(PuppetWidget* widget)
 364         : Runnable("PuppetWidget::PaintTask"), mWidget(widget) {}
 365     void Revoke() { mWidget = nullptr; }
 366
 367    private:
 368     PuppetWidget* mWidget;
 369   };
 370
 371   // BrowserChild normally holds a strong reference to this PuppetWidget
 372   // or its root ancestor, but each PuppetWidget also needs a
 373   // reference back to BrowserChild (e.g. to delegate nsIWidget IME calls
 374   // to chrome) So we hold a weak reference to BrowserChild here.  Since
 375   // it's possible for BrowserChild to outlive the PuppetWidget, we clear
 376   // this weak reference in Destroy()
 377   BrowserChild* mBrowserChild;
 378   // The "widget" to which we delegate events if we don't have an
 379   // event handler.
 380   RefPtr<PuppetWidget> mChild;
 381   LayoutDeviceIntRegion mDirtyRegion;
 382   nsRevocableEventPtr<PaintTask> mPaintTask;
 383   RefPtr<layers::MemoryPressureObserver> mMemoryPressureObserver;
 384   // XXX/cjones: keeping this around until we teach LayerManager to do
 385   // retained-content-only transactions
 386   RefPtr<DrawTarget> mDrawTarget;
 387   // IME
 388   IMENotificationRequests mIMENotificationRequestsOfParent;
 389   InputContext mInputContext;
 390   // mNativeIMEContext is initialized when this dispatches every composition
 391   // event both from parent process's widget and TextEventDispatcher in same
 392   // process.  If it hasn't been started composition yet, this isn't necessary
 393   // for XP code since there is no TextComposition instance which is caused by
 394   // the PuppetWidget instance.
 395   NativeIMEContext mNativeIMEContext;
 396   ContentCacheInChild mContentCache;
 397
 398   // The DPI of the screen corresponding to this widget
 399   float mDPI;
 400   int32_t mRounding;
 401   double mDefaultScale;
 402
 403   nsCOMPtr<imgIContainer> mCustomCursor;
 404   uint32_t mCursorHotspotX, mCursorHotspotY;
 405
 406   ScreenIntMargin mSafeAreaInsets;
 407
 408   nsCOMArray<nsIKeyEventInPluginCallback> mKeyEventInPluginCallbacks;
 409
 410   RefPtr<TextEventDispatcherListener> mNativeTextEventDispatcherListener;
 411
 412  protected:
 413   bool mEnabled;
 414   bool mVisible;
 415
 416  private:
 417   bool mNeedIMEStateInit;
 418   // When remote process requests to commit/cancel a composition, the
 419   // composition may have already been committed in the main process.  In such
 420   // case, this will receive remaining composition events for the old
 421   // composition even after requesting to commit/cancel the old composition
 422   // but the TextComposition for the old composition has already been destroyed.
 423   // So, until this meets new eCompositionStart, following composition events
 424   // should be ignored if this is set to true.
 425   bool mIgnoreCompositionEvents;
 426 };
 427
 428 class PuppetScreen : public nsBaseScreen {
 429  public:
 430   explicit PuppetScreen(void* nativeScreen);
 431   ~PuppetScreen();
 432
 433   NS_IMETHOD GetRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth,
 434                      int32_t* aHeight) override;
 435   NS_IMETHOD GetAvailRect(int32_t* aLeft, int32_t* aTop, int32_t* aWidth,
 436                           int32_t* aHeight) override;
 437   NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth) override;
 438   NS_IMETHOD GetColorDepth(int32_t* aColorDepth) override;
 439 };
 440
 441 class PuppetScreenManager final : public nsIScreenManager {
 442   ~PuppetScreenManager();
 443
 444  public:
 445   PuppetScreenManager();
 446
 447   NS_DECL_ISUPPORTS
 448   NS_DECL_NSISCREENMANAGER
 449
 450  protected:
 451   nsCOMPtr<nsIScreen> mOneScreen;
 452 };
 453
 454 }  // namespace widget
 455 }  // namespace mozilla
 456
 457 #endif  // mozilla_widget_PuppetWidget_h__