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