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)
  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    * Return the size of the drawable area of the widget.
 195    */
 196   virtual LayoutDeviceIntSize GetClientSize() = 0;
 197
 198   /**
 199    * Return the internal format of the default framebuffer for this
 200    * widget.
 201    */
 202   virtual uint32_t GetGLFrameBufferFormat();
 203
 204   /*
 205    * Access the underlying nsIWidget. This method will be removed when the
 206    * compositor no longer depends on nsIWidget on any platform.
 207    */
 208   virtual nsIWidget* RealWidget() = 0;
 209
 210   /**
 211    * Clean up any resources used by Start/EndRemoteDrawing.
 212    *
 213    * Called by BasicCompositor on the compositor thread for OMTC drawing
 214    * when the compositor is destroyed.
 215    */
 216   virtual void CleanupRemoteDrawing();
 217
 218   /**
 219    * Return a key that can represent the widget object round-trip across the
 220    * CompositorBridge channel. This only needs to be implemented on GTK and
 221    * Windows.
 222    *
 223    * The key must be the nsIWidget pointer cast to a uintptr_t. See
 224    * CompositorBridgeChild::RecvHideAllPlugins and
 225    * CompositorBridgeParent::SendHideAllPlugins.
 226    */
 227   virtual uintptr_t GetWidgetKey() { return 0; }
 228
 229   /**
 230    * Create a backbuffer for the software compositor.
 231    */
 232   virtual already_AddRefed<gfx::DrawTarget> GetBackBufferDrawTarget(
 233       gfx::DrawTarget* aScreenTarget, const gfx::IntRect& aRect,
 234       bool* aOutIsCleared);
 235
 236   /**
 237    * Ensure end of composition to back buffer.
 238    *
 239    * Called by BasicCompositor on the compositor thread for OMTC drawing
 240    * after each composition to back buffer.
 241    */
 242   virtual already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing();
 243
 244   /**
 245    * Observe or unobserve vsync.
 246    */
 247   virtual void ObserveVsync(VsyncObserver* aObserver) = 0;
 248
 249   /**
 250    * Get the compositor options for the compositor associated with this
 251    * CompositorWidget.
 252    */
 253   const layers::CompositorOptions& GetCompositorOptions() { return mOptions; }
 254
 255   /**
 256    * Return true if the window is hidden and should not be composited.
 257    */
 258   virtual bool IsHidden() const { return false; }
 259
 260   /**
 261    * This is only used by out-of-process compositors.
 262    */
 263   virtual RefPtr<VsyncObserver> GetVsyncObserver() const;
 264
 265   virtual WinCompositorWidget* AsWindows() { return nullptr; }
 266   virtual GtkCompositorWidget* AsGTK() { return nullptr; }
 267   virtual AndroidCompositorWidget* AsAndroid() { return nullptr; }
 268
 269   /**
 270    * Return the platform-specific delegate for the widget, if any.
 271    */
 272   virtual CompositorWidgetDelegate* AsDelegate() { return nullptr; }
 273
 274  protected:
 275   explicit CompositorWidget(const layers::CompositorOptions& aOptions);
 276   virtual ~CompositorWidget();
 277
 278   // Back buffer of BasicCompositor
 279   RefPtr<gfx::DrawTarget> mLastBackBuffer;
 280
 281   layers::CompositorOptions mOptions;
 282 };
 283
 284 }  // namespace widget
 285 }  // namespace mozilla
 286
 287 #endif