/src/mozilla-central/widget/CompositorWidget.h

Source (jump to first uncovered line)
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_widget_CompositorWidget_h__
#define mozilla_widget_CompositorWidget_h__

#include "nsISupports.h"
#include "mozilla/RefPtr.h"
#include "Units.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/layers/CompositorOptions.h"
#include "mozilla/layers/LayersTypes.h"

class nsIWidget;
class nsBaseWidget;

namespace mozilla {
class VsyncObserver;
namespace gl {
class GLContext;
} // namespace gl
namespace layers {
class Compositor;
class LayerManager;
class LayerManagerComposite;
class Compositor;
} // namespace layers
namespace gfx {
class DrawTarget;
class SourceSurface;
} // namespace gfx
namespace widget {

class WinCompositorWidget;
class GtkCompositorWidget;
class AndroidCompositorWidget;
class CompositorWidgetInitData;

// Gecko widgets usually need to communicate with the CompositorWidget with
// platform-specific messages (for example to update the window size or
// transparency). This functionality is controlled through a "host". Since
// this functionality is platform-dependent, it is only forward declared
// here.
class PlatformCompositorWidgetDelegate;

// Headless mode uses its own, singular CompositorWidget implementation.
class HeadlessCompositorWidget;

class CompositorWidgetDelegate
{
public:
  virtual PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() {
    return nullptr;
  }

  virtual HeadlessCompositorWidget* AsHeadlessCompositorWidget() {
    return nullptr;
  }
};

// Platforms that support out-of-process widgets.
#if defined(XP_WIN) || defined(MOZ_X11)
// CompositorWidgetParent should implement CompositorWidget and
// PCompositorWidgetParent.
class CompositorWidgetParent;

// CompositorWidgetChild should implement CompositorWidgetDelegate and
// PCompositorWidgetChild.
class CompositorWidgetChild;

# define MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
#endif

class WidgetRenderingContext
{
public:
#if defined(XP_MACOSX)
  WidgetRenderingContext()
    : mLayerManager(nullptr)
    , mGL(nullptr) {}
  layers::LayerManagerComposite* mLayerManager;
  gl::GLContext* mGL;
#elif defined(MOZ_WIDGET_ANDROID)
  WidgetRenderingContext() : mCompositor(nullptr) {}
  layers::Compositor* mCompositor;
#endif
};

/**
 * Access to a widget from the compositor is restricted to these methods.
 */
class CompositorWidget
{
public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(mozilla::widget::CompositorWidget)

  /**
   * Create an in-process compositor widget. aWidget may be ignored if the
   * platform does not require it.
   */
  static RefPtr<CompositorWidget> CreateLocal(const CompositorWidgetInitData& aInitData,
                                              const layers::CompositorOptions& aOptions,
                                              nsIWidget* aWidget);

  /**
   * Called before rendering using OMTC. Returns false when the widget is
   * not ready to be rendered (for example while the window is closed).
   *
   * Always called from the compositing thread, which may be the main-thread if
   * OMTC is not enabled.
   */
  virtual bool PreRender(WidgetRenderingContext* aContext) {
    return true;
  }

  /**
   * Called after rendering using OMTC. Not called when rendering was
   * cancelled by a negative return value from PreRender.
   *
   * Always called from the compositing thread, which may be the main-thread if
   * OMTC is not enabled.
   */
  virtual void PostRender(WidgetRenderingContext* aContext)
  {}

  /**
   * Called before the LayerManager draws the layer tree.
   *
   * Always called from the compositing thread.
   */
  virtual void DrawWindowUnderlay(WidgetRenderingContext* aContext,
                                  LayoutDeviceIntRect aRect)
  {}

  /**
   * Called after the LayerManager draws the layer tree
   *
   * Always called from the compositing thread.
   */
  virtual void DrawWindowOverlay(WidgetRenderingContext* aContext,
                                 LayoutDeviceIntRect aRect)
  {}

  /**
   * Return a DrawTarget for the window which can be composited into.
   *
   * Called by BasicCompositor on the compositor thread for OMTC drawing
   * before each composition.
   *
   * The window may specify its buffer mode. If unspecified, it is assumed
   * to require double-buffering.
   */
  virtual already_AddRefed<gfx::DrawTarget> StartRemoteDrawing();
  virtual already_AddRefed<gfx::DrawTarget>
  StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
                             layers::BufferMode* aBufferMode)
  {
    return StartRemoteDrawing();
  }

  /**
   * Ensure that what was painted into the DrawTarget returned from
   * StartRemoteDrawing reaches the screen.
   *
   * Called by BasicCompositor on the compositor thread for OMTC drawing
   * after each composition.
   */
  virtual void EndRemoteDrawing()
  {}
  virtual void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
                                        LayoutDeviceIntRegion& aInvalidRegion)
  {
    EndRemoteDrawing();
  }

  /**
   * Return true when it is better to defer EndRemoteDrawing().
   *
   * Called by BasicCompositor on the compositor thread for OMTC drawing
   * after each composition.
   */
  virtual bool NeedsToDeferEndRemoteDrawing() {
    return false;
  }

  /**
   * Called when shutting down the LayerManager to clean-up any cached resources.
   *
   * Always called from the compositing thread.
   */
  virtual void CleanupWindowEffects()
  {}

  /**
   * A hook for the widget to prepare a Compositor, during the latter's initialization.
   *
   * If this method returns true, it means that the widget will be able to
   * present frames from the compoositor.
   *
   * Returning false will cause the compositor's initialization to fail, and
   * a different compositor backend will be used (if any).
   */
  virtual bool InitCompositor(layers::Compositor* aCompositor) {
    return true;
  }

  /**
   * Return the size of the drawable area of the widget.
   */
  virtual LayoutDeviceIntSize GetClientSize() = 0;

  /**
   * Return the internal format of the default framebuffer for this
   * widget.
   */
  virtual uint32_t GetGLFrameBufferFormat();

  /*
   * Access the underlying nsIWidget. This method will be removed when the compositor no longer
   * depends on nsIWidget on any platform.
   */
  virtual nsIWidget* RealWidget() = 0;

  /**
   * Clean up any resources used by Start/EndRemoteDrawing.
   *
   * Called by BasicCompositor on the compositor thread for OMTC drawing
   * when the compositor is destroyed.
   */
  virtual void CleanupRemoteDrawing();

  /**
   * Return a key that can represent the widget object round-trip across the
   * CompositorBridge channel. This only needs to be implemented on GTK and
   * Windows.
   *
   * The key must be the nsIWidget pointer cast to a uintptr_t. See
   * CompositorBridgeChild::RecvHideAllPlugins and
   * CompositorBridgeParent::SendHideAllPlugins.
   */
  virtual uintptr_t GetWidgetKey() {
    return 0;
  }

  /**
   * Create a backbuffer for the software compositor.
   */
  virtual already_AddRefed<gfx::DrawTarget>
  GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
                          const LayoutDeviceIntRect& aRect,
                          const LayoutDeviceIntRect& aClearRect);

  /**
   * Ensure end of composition to back buffer.
   *
   * Called by BasicCompositor on the compositor thread for OMTC drawing
   * after each composition to back buffer.
   */
  virtual already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing();

  /**
   * Observe or unobserve vsync.
   */
  virtual void ObserveVsync(VsyncObserver* aObserver) = 0;

  /**
   * Get the compositor options for the compositor associated with this
   * CompositorWidget.
   */
  const layers::CompositorOptions& GetCompositorOptions() {
    return mOptions;
  }

  /**
   * Return true if the window is hidden and should not be composited.
   */
  virtual bool IsHidden() const {
    return false;
  }

  /**
   * This is only used by out-of-process compositors.
   */
  virtual RefPtr<VsyncObserver> GetVsyncObserver() const;

  virtual WinCompositorWidget* AsWindows() {
    return nullptr;
  }
  virtual GtkCompositorWidget* AsX11() {
    return nullptr;
  }
  virtual AndroidCompositorWidget* AsAndroid() {
    return nullptr;
  }

  /**
   * Return the platform-specific delegate for the widget, if any.
   */
  virtual CompositorWidgetDelegate* AsDelegate() {
    return nullptr;
  }

protected:
  explicit CompositorWidget(const layers::CompositorOptions& aOptions);
  virtual ~CompositorWidget();

  // Back buffer of BasicCompositor
  RefPtr<gfx::DrawTarget> mLastBackBuffer;

  layers::CompositorOptions mOptions;
};

} // namespace widget
} // namespace mozilla

#endif

Coverage Report

Created: 2018-09-25 14:53

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