mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-10 20:05:49 +00:00
6fcebfbe5b
To make the HeadlessCompositorWidget work under Windows as well as Linux, I had
to change the way that I hooked it into the existing CompositorWidget system.
Under GTK, the CompositorWidgetInitData and CompositorWidgetDelegate types
provided the information needed by the headless compositor widget already (the
widget client size). On Windows, however, the definitions of these types
differ, and the client size information is simply retrieved from the platform
APIs when needed.
After this patch, CompositorWidgetDelegate is renamed to
PlatformCompositorWidgetDelegate, and a new base class called
CompositorWidgetDelegate is added with "AsPlatformSpecificDelegate()" and
"AsHeadlessCompositorWidget()" methods. In non-headless mode, widgets use
AsPlatformSpecificDelegate() to access the Windows- and GTK-specific delegate
APIs. In headless mode, AsHeadlessCompositorWidget() is used to access the
singular CompositorWidget implementation for headless. Meanwhile, the
CompositorWidgetInitData IPDL type is made into a union which always contains a
headless-specific HeadlessCompositorWidgetInitData struct and under GTK and
Windows also contains an {X11,Win}CompositorWidgetInitData struct.
This also includes a small patch to ensure that the GPU process and
hardware-accelerated compositing are always disabled under headless mode. These
features weren't activated by default in the Linux environments I tested in, but
did end up activating (and then promptly crashing Firefox) when I tested on
Windows.
MozReview-Commit-ID: CocPoHBDV7H
--HG--
extra : rebase_source : 4581fa63aa3a9f32a8dc2672015a35b9be01b20f
127 lines
3.8 KiB
C++
127 lines
3.8 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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 widget_windows_CompositorWidgetParent_h
|
|
#define widget_windows_CompositorWidgetParent_h
|
|
|
|
#include "CompositorWidget.h"
|
|
#include "gfxASurface.h"
|
|
#include "mozilla/gfx/CriticalSection.h"
|
|
#include "mozilla/gfx/Point.h"
|
|
#include "nsIWidget.h"
|
|
|
|
class nsWindow;
|
|
|
|
namespace mozilla {
|
|
namespace widget {
|
|
|
|
class PlatformCompositorWidgetDelegate
|
|
: public CompositorWidgetDelegate
|
|
{
|
|
public:
|
|
// Callbacks for nsWindow.
|
|
virtual void EnterPresentLock() = 0;
|
|
virtual void LeavePresentLock() = 0;
|
|
virtual void OnDestroyWindow() = 0;
|
|
|
|
// Transparency handling.
|
|
virtual void UpdateTransparency(nsTransparencyMode aMode) = 0;
|
|
virtual void ClearTransparentWindow() = 0;
|
|
|
|
// If in-process and using software rendering, return the backing transparent
|
|
// DC.
|
|
virtual HDC GetTransparentDC() const = 0;
|
|
|
|
// CompositorWidgetDelegate Overrides
|
|
|
|
PlatformCompositorWidgetDelegate* AsPlatformSpecificDelegate() override {
|
|
return this;
|
|
}
|
|
};
|
|
|
|
class WinCompositorWidgetInitData;
|
|
|
|
// This is the Windows-specific implementation of CompositorWidget. For
|
|
// the most part it only requires an HWND, however it maintains extra state
|
|
// for transparent windows, as well as for synchronizing WM_SETTEXT messages
|
|
// with the compositor.
|
|
class WinCompositorWidget
|
|
: public CompositorWidget,
|
|
public PlatformCompositorWidgetDelegate
|
|
{
|
|
public:
|
|
WinCompositorWidget(const WinCompositorWidgetInitData& aInitData,
|
|
const layers::CompositorOptions& aOptions);
|
|
|
|
// CompositorWidget Overrides
|
|
|
|
bool PreRender(WidgetRenderingContext*) override;
|
|
void PostRender(WidgetRenderingContext*) override;
|
|
already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
|
|
void EndRemoteDrawing() override;
|
|
bool NeedsToDeferEndRemoteDrawing() override;
|
|
LayoutDeviceIntSize GetClientSize() override;
|
|
already_AddRefed<gfx::DrawTarget> GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
|
|
const LayoutDeviceIntRect& aRect,
|
|
const LayoutDeviceIntRect& aClearRect) override;
|
|
already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing() override;
|
|
bool InitCompositor(layers::Compositor* aCompositor) override;
|
|
uintptr_t GetWidgetKey() override;
|
|
WinCompositorWidget* AsWindows() override {
|
|
return this;
|
|
}
|
|
CompositorWidgetDelegate* AsDelegate() override {
|
|
return this;
|
|
}
|
|
bool IsHidden() const override;
|
|
|
|
// PlatformCompositorWidgetDelegate Overrides
|
|
|
|
void EnterPresentLock() override;
|
|
void LeavePresentLock() override;
|
|
void OnDestroyWindow() override;
|
|
void UpdateTransparency(nsTransparencyMode aMode) override;
|
|
void ClearTransparentWindow() override;
|
|
|
|
bool RedrawTransparentWindow();
|
|
|
|
// Ensure that a transparent surface exists, then return it.
|
|
RefPtr<gfxASurface> EnsureTransparentSurface();
|
|
|
|
HDC GetTransparentDC() const override {
|
|
return mMemoryDC;
|
|
}
|
|
HWND GetHwnd() const {
|
|
return mWnd;
|
|
}
|
|
|
|
private:
|
|
HDC GetWindowSurface();
|
|
void FreeWindowSurface(HDC dc);
|
|
|
|
void CreateTransparentSurface(const gfx::IntSize& aSize);
|
|
|
|
private:
|
|
uintptr_t mWidgetKey;
|
|
HWND mWnd;
|
|
gfx::CriticalSection mPresentLock;
|
|
|
|
// Transparency handling.
|
|
nsTransparencyMode mTransparencyMode;
|
|
RefPtr<gfxASurface> mTransparentSurface;
|
|
HDC mMemoryDC;
|
|
HDC mCompositeDC;
|
|
|
|
// Locked back buffer of BasicCompositor
|
|
uint8_t* mLockedBackBufferData;
|
|
|
|
bool mNotDeferEndRemoteDrawing;
|
|
};
|
|
|
|
} // namespace widget
|
|
} // namespace mozilla
|
|
|
|
#endif // widget_windows_CompositorWidgetParent_h
|