widget/CompositorWidget.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef mozilla_widget_CompositorWidget_h__
   6 #define mozilla_widget_CompositorWidget_h__
   7
   8 #include "nsISupports.h"
   9 #include "mozilla/RefPtr.h"
  10 #include "Units.h"
  11 #include "mozilla/gfx/Rect.h"
  12 #include "mozilla/layers/CompositorOptions.h"
  13 #include "mozilla/layers/LayersTypes.h"
  14
  15 #ifdef MOZ_IS_GCC
  16 #  include "mozilla/layers/NativeLayer.h"
  17 #endif
  18
  19 class nsIWidget;
  20 class nsBaseWidget;
  21
  22 namespace mozilla {
  23 class VsyncObserver;
  24 namespace gl {
  25 class GLContext;
  26 }  // namespace gl
  27 namespace layers {
  28 class Compositor;
  29 class LayerManager;
  30 class NativeLayerRoot;
  31 }  // namespace layers
  32 namespace gfx {
  33 class DrawTarget;
  34 class SourceSurface;
  35 }  // namespace gfx
  36 namespace widget {
  37
  38 class WinCompositorWidget;
  39 class GtkCompositorWidget;
  40 class AndroidCompositorWidget;
  41 class CompositorWidgetInitData;
  42
  43 // Gecko widgets usually need to communicate with the CompositorWidget with
  44 // platform-specific messages (for example to update the window size or
  45 // transparency). This functionality is controlled through a "host". Since
  46 // this functionality is platform-dependent, it is only forward declared
  47 // here.
  48 class PlatformCompositorWidgetDelegate;
  49
  50 // Headless mode uses its own, singular CompositorWidget implementation.
  51 class HeadlessCompositorWidget;
  52
  53 class CompositorWidgetDelegate {
  54  public:
  55   virtual PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() {
  56     return nullptr;
  57   }
  58
  59   virtual HeadlessCompositorWidget* AsHeadlessCompositorWidget() {
  60     return nullptr;
  61   }
  62 };
  63
  64 // Platforms that support out-of-process widgets.
  65 #if defined(XP_WIN) || defined(MOZ_X11) || defined(MOZ_WIDGET_ANDROID)
  66 // CompositorWidgetParent should implement CompositorWidget and
  67 // PCompositorWidgetParent.
  68 class CompositorWidgetParent;
  69
  70 // CompositorWidgetChild should implement CompositorWidgetDelegate and
  71 // PCompositorWidgetChild.
  72 class CompositorWidgetChild;
  73
  74 #  define MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
  75 #endif
  76
  77 class WidgetRenderingContext {
  78  public:
  79 #if defined(XP_MACOSX)
  80   gl::GLContext* mGL = nullptr;
  81 #endif
  82 };
  83
  84 /**
  85  * Access to a widget from the compositor is restricted to these methods.
  86  */
  87 class CompositorWidget {
  88  public:
  89   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(mozilla::widget::CompositorWidget)
  90
  91   /**
  92    * Create an in-process compositor widget. aWidget may be ignored if the
  93    * platform does not require it.
  94    */
  95   static RefPtr<CompositorWidget> CreateLocal(
  96       const CompositorWidgetInitData& aInitData,
  97       const layers::CompositorOptions& aOptions, nsIWidget* aWidget);
  98
  99   /**
 100    * Called before rendering using OMTC. Returns false when the widget is
 101    * not ready to be rendered (for example while the window is closed).
 102    *
 103    * Always called from the compositing thread, which may be the main-thread if
 104    * OMTC is not enabled.
 105    */
 106   virtual bool PreRender(WidgetRenderingContext* aContext) { return true; }
 107
 108   /**
 109    * Called after rendering using OMTC. Not called when rendering was
 110    * cancelled by a negative return value from PreRender.
 111    *
 112    * Always called from the compositing thread, which may be the main-thread if
 113    * OMTC is not enabled.
 114    */
 115   virtual void PostRender(WidgetRenderingContext* aContext) {}
 116
 117   /**
 118    * Called before the first composite. If the result is non-null, one or more
 119    * native layers will be placed on the window and used for compositing.
 120    * When native layers are used, StartRemoteDrawing(InRegion) and
 121    * EndRemoteDrawing(InRegion) will not be called.
 122    */
 123   virtual RefPtr<layers::NativeLayerRoot> GetNativeLayerRoot() {
 124     return nullptr;
 125   }
 126
 127   /**
 128    * Return a DrawTarget for the window which can be composited into.
 129    *
 130    * Only called if GetNativeLayerRoot() returns nullptr.
 131    * Called by BasicCompositor on the compositor thread for OMTC drawing
 132    * before each composition (unless there's a native layer root).
 133    *
 134    * The window may specify its buffer mode. If unspecified, it is assumed
 135    * to require double-buffering.
 136    */
 137   virtual already_AddRefed<gfx::DrawTarget> StartRemoteDrawing();
 138   virtual already_AddRefed<gfx::DrawTarget> StartRemoteDrawingInRegion(
 139       const LayoutDeviceIntRegion& aInvalidRegion,
 140       layers::BufferMode* aBufferMode) {
 141     return StartRemoteDrawing();
 142   }
 143
 144   /**
 145    * Ensure that what was painted into the DrawTarget returned from
 146    * StartRemoteDrawing reaches the screen.
 147    *
 148    * Called by BasicCompositor on the compositor thread for OMTC drawing
 149    * after each composition for which StartRemoteDrawing(InRegion) was called.
 150    */
 151   virtual void EndRemoteDrawing() {}
 152   virtual void EndRemoteDrawingInRegion(
 153       gfx::DrawTarget* aDrawTarget,
 154       const LayoutDeviceIntRegion& aInvalidRegion) {
 155     EndRemoteDrawing();
 156   }
 157
 158   /**
 159    * Return true when it is better to defer EndRemoteDrawing().
 160    *
 161    * Called by BasicCompositor on the compositor thread for OMTC drawing
 162    * after each composition.
 163    */
 164   virtual bool NeedsToDeferEndRemoteDrawing() { return false; }
 165
 166   /**
 167    * Some widgets (namely Gtk) may need clean up underlying surface
 168    * before painting to draw transparent objects correctly. Return
 169    * the transparent region where this clearing is required.
 170    */
 171   virtual LayoutDeviceIntRegion GetTransparentRegion();
 172
 173   /**
 174    * Called when shutting down the LayerManager to clean-up any cached
 175    * resources.
 176    *
 177    * Always called from the compositing thread.
 178    */
 179   virtual void CleanupWindowEffects() {}
 180
 181   /**
 182    * A hook for the widget to prepare a Compositor, during the latter's
 183    * initialization.
 184    *
 185    * If this method returns true, it means that the widget will be able to
 186    * present frames from the compoositor.
 187    *
 188    * Returning false will cause the compositor's initialization to fail, and
 189    * a different compositor backend will be used (if any).
 190    */
 191   virtual bool InitCompositor(layers::Compositor* aCompositor) { return true; }
 192
 193   /**
 194    * A hook that is ran whenever composition is resumed.
 195    *
 196    * This is called from CompositorBridgeParent::ResumeComposition,
 197    * immediately prior to webrender being resumed.
 198    *
 199    * Returns true if composition can be successfully resumed, else false.
 200    */
 201   virtual bool OnResumeComposition() { return true; }
 202
 203   /**
 204    * Return the size of the drawable area of the widget.
 205    */
 206   virtual LayoutDeviceIntSize GetClientSize() = 0;
 207
 208   /**
 209    * Return the internal format of the default framebuffer for this
 210    * widget.
 211    */
 212   virtual uint32_t GetGLFrameBufferFormat();
 213
 214   /*
 215    * Access the underlying nsIWidget. This method will be removed when the
 216    * compositor no longer depends on nsIWidget on any platform.
 217    */
 218   virtual nsIWidget* RealWidget() = 0;
 219
 220   /**
 221    * Clean up any resources used by Start/EndRemoteDrawing.
 222    *
 223    * Called by BasicCompositor on the compositor thread for OMTC drawing
 224    * when the compositor is destroyed.
 225    */
 226   virtual void CleanupRemoteDrawing();
 227
 228   /**
 229    * Return a key that can represent the widget object round-trip across the
 230    * CompositorBridge channel. This only needs to be implemented on GTK and
 231    * Windows.
 232    *
 233    * The key must be the nsIWidget pointer cast to a uintptr_t. See
 234    * CompositorBridgeChild::RecvHideAllPlugins and
 235    * CompositorBridgeParent::SendHideAllPlugins.
 236    */
 237   virtual uintptr_t GetWidgetKey() { return 0; }
 238
 239   /**
 240    * Create a backbuffer for the software compositor.
 241    */
 242   virtual already_AddRefed<gfx::DrawTarget> GetBackBufferDrawTarget(
 243       gfx::DrawTarget* aScreenTarget, const gfx::IntRect& aRect,
 244       bool* aOutIsCleared);
 245
 246   /**
 247    * Ensure end of composition to back buffer.
 248    *
 249    * Called by BasicCompositor on the compositor thread for OMTC drawing
 250    * after each composition to back buffer.
 251    */
 252   virtual already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing();
 253
 254   /**
 255    * Observe or unobserve vsync.
 256    */
 257   virtual void ObserveVsync(VsyncObserver* aObserver) = 0;
 258
 259   /**
 260    * Get the compositor options for the compositor associated with this
 261    * CompositorWidget.
 262    */
 263   const layers::CompositorOptions& GetCompositorOptions() { return mOptions; }
 264
 265   /**
 266    * Return true if the window is hidden and should not be composited.
 267    */
 268   virtual bool IsHidden() const { return false; }
 269
 270   /**
 271    * This is only used by out-of-process compositors.
 272    */
 273   virtual RefPtr<VsyncObserver> GetVsyncObserver() const;
 274
 275   virtual WinCompositorWidget* AsWindows() { return nullptr; }
 276   virtual GtkCompositorWidget* AsGTK() { return nullptr; }
 277   virtual AndroidCompositorWidget* AsAndroid() { return nullptr; }
 278
 279   /**
 280    * Return the platform-specific delegate for the widget, if any.
 281    */
 282   virtual CompositorWidgetDelegate* AsDelegate() { return nullptr; }
 283
 284  protected:
 285   explicit CompositorWidget(const layers::CompositorOptions& aOptions);
 286   virtual ~CompositorWidget();
 287
 288   // Back buffer of BasicCompositor
 289   RefPtr<gfx::DrawTarget> mLastBackBuffer;
 290
 291   layers::CompositorOptions mOptions;
 292 };
 293
 294 }  // namespace widget
 295 }  // namespace mozilla
 296
 297 #endif