Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-26 20:30:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Back out 7 changesets (bug 1281998) for Windows Marionette crashes

Browse Source 
Backed out changeset d806fac2c856 (bug 1281998)
Backed out changeset b8d4fedfd7eb (bug 1281998)
Backed out changeset a72929c0c3ec (bug 1281998)
Backed out changeset 74198f88fa37 (bug 1281998)
Backed out changeset 54a0e73f6906 (bug 1281998)
Backed out changeset 99d1da1293b7 (bug 1281998)
Backed out changeset a5a9585754b1 (bug 1281998)

--HG--
rename : widget/CompositorWidget.cpp => widget/CompositorWidgetProxy.cpp
rename : widget/CompositorWidget.h => widget/CompositorWidgetProxy.h
rename : widget/windows/WinCompositorWidget.cpp => widget/windows/WinCompositorWidgetProxy.cpp
rename : widget/windows/WinCompositorWidget.h => widget/windows/WinCompositorWidgetProxy.h
This commit is contained in:
Phil Ringnalda 2016-06-29 19:35:24 -07:00
parent 93890f7d54
commit 0d0d24bccc
46 changed files with 421 additions and 923 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
gfx/ipc/CompositorSession.cpp
View File

@ -6,19 +6,16 @@
#include "CompositorSession.h"
#include "mozilla/layers/CompositorBridgeChild.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/widget/PlatformWidgetTypes.h"
#include "base/process_util.h"
namespace mozilla {
namespace layers {
using namespace widget;
class InProcessCompositorSession final : public CompositorSession
{
public:
InProcessCompositorSession(
nsIWidget* aWidget,
widget::CompositorWidgetProxy* aWidgetProxy,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
@ -33,11 +30,10 @@ public:
private:
RefPtr<CompositorBridgeParent> mCompositorBridgeParent;
RefPtr<CompositorWidget> mCompositorWidget;
};
already_AddRefed<CompositorSession>
CompositorSession::CreateInProcess(nsIWidget* aWidget,
CompositorSession::CreateInProcess(widget::CompositorWidgetProxy* aWidgetProxy,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
@ -45,7 +41,7 @@ CompositorSession::CreateInProcess(nsIWidget* aWidget,
const gfx::IntSize& aSurfaceSize)
{
RefPtr<InProcessCompositorSession> session = new InProcessCompositorSession(
aWidget,
aWidgetProxy,
aLayerManager,
aScale,
aUseAPZ,
@ -55,7 +51,6 @@ CompositorSession::CreateInProcess(nsIWidget* aWidget,
}
CompositorSession::CompositorSession()
: mCompositorWidgetDelegate(nullptr)
{
}
@ -69,20 +64,15 @@ CompositorSession::GetCompositorBridgeChild()
return mCompositorBridgeChild;
}
InProcessCompositorSession::InProcessCompositorSession(nsIWidget* aWidget,
InProcessCompositorSession::InProcessCompositorSession(widget::CompositorWidgetProxy* aWidgetProxy,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
{
CompositorWidgetInitData initData;
aWidget->GetCompositorWidgetInitData(&initData);
mCompositorWidget = CompositorWidget::CreateLocal(initData, aWidget);
mCompositorWidgetDelegate = mCompositorWidget->AsDelegate();
mCompositorBridgeParent = new CompositorBridgeParent(
mCompositorWidget,
aWidgetProxy,
aScale,
aUseAPZ,
aUseExternalSurfaceSize,
@ -126,7 +116,6 @@ InProcessCompositorSession::Shutdown()
mCompositorBridgeChild->Destroy();
mCompositorBridgeChild = nullptr;
mCompositorBridgeParent = nullptr;
mCompositorWidget = nullptr;
}
} // namespace layers

17
gfx/ipc/CompositorSession.h
View File

@ -11,12 +11,9 @@
#include "nsISupportsImpl.h"
#include "mozilla/gfx/Point.h"
class nsIWidget;
namespace mozilla {
namespace widget {
class CompositorWidget;
class CompositorWidgetDelegate;
class CompositorWidgetProxy;
} // namespace widget
namespace gfx {
class GPUProcessManager;
@ -35,10 +32,6 @@ class CompositorSession
{
friend class gfx::GPUProcessManager;
protected:
typedef widget::CompositorWidget CompositorWidget;
typedef widget::CompositorWidgetDelegate CompositorWidgetDelegate;
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositorSession)
@ -59,17 +52,12 @@ public:
// Return the child end of the compositor IPC bridge.
CompositorBridgeChild* GetCompositorBridgeChild();
// Return the proxy for accessing the compositor's widget.
CompositorWidgetDelegate* GetCompositorWidgetDelegate() {
return mCompositorWidgetDelegate;
}
protected:
CompositorSession();
virtual ~CompositorSession();
static already_AddRefed<CompositorSession> CreateInProcess(
nsIWidget* aWidget,
widget::CompositorWidgetProxy* aWidgetProxy,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
@ -78,7 +66,6 @@ protected:
protected:
RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
CompositorWidgetDelegate* mCompositorWidgetDelegate;
private:
DISALLOW_COPY_AND_ASSIGN(CompositorSession);

4
gfx/ipc/GPUProcessManager.cpp
View File

@ -150,7 +150,7 @@ GPUProcessManager::DestroyProcess()
}
already_AddRefed<CompositorSession>
GPUProcessManager::CreateTopLevelCompositor(nsIWidget* aWidget,
GPUProcessManager::CreateTopLevelCompositor(widget::CompositorWidgetProxy* aProxy,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
@ -158,7 +158,7 @@ GPUProcessManager::CreateTopLevelCompositor(nsIWidget* aWidget,
const gfx::IntSize& aSurfaceSize)
{
return CompositorSession::CreateInProcess(
aWidget,
aProxy,
aLayerManager,
aScale,
aUseAPZ,

4
gfx/ipc/GPUProcessManager.h
View File

@ -24,7 +24,7 @@ class CompositorUpdateObserver;
class PCompositorBridgeParent;
} // namespace layers
namespace widget {
class CompositorWidget;
class CompositorWidgetProxy;
} // namespace widget
namespace dom {
class ContentParent;
@ -61,7 +61,7 @@ public:
void EnsureGPUReady();
already_AddRefed<layers::CompositorSession> CreateTopLevelCompositor(
nsIWidget* aWidget,
widget::CompositorWidgetProxy* aProxy,
layers::ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,

2
gfx/layers/Compositor.cpp
View File

@ -25,7 +25,7 @@ namespace mozilla {
namespace layers {
Compositor::Compositor(widget::CompositorWidget* aWidget,
Compositor::Compositor(widget::CompositorWidgetProxy* aWidget,
CompositorBridgeParent* aParent)
: mCompositorID(0)
, mDiagnosticTypes(DiagnosticTypes::NO_DIAGNOSTIC)

8
gfx/layers/Compositor.h
View File

@ -17,11 +17,11 @@
#include "mozilla/layers/CompositorTypes.h" // for DiagnosticTypes, etc
#include "mozilla/layers/FenceUtils.h" // for FenceHandle
#include "mozilla/layers/LayersTypes.h" // for LayersBackend
#include "mozilla/widget/CompositorWidget.h"
#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc
#include "nsRegion.h"
#include <vector>
#include "mozilla/WidgetUtils.h"
#include "CompositorWidgetProxy.h"
/**
* Different elements of a web pages are rendered into separate "layers" before
@ -192,7 +192,7 @@ protected:
public:
NS_INLINE_DECL_REFCOUNTING(Compositor)
explicit Compositor(widget::CompositorWidget* aWidget,
explicit Compositor(widget::CompositorWidgetProxy* aWidget,
CompositorBridgeParent* aParent = nullptr);
virtual already_AddRefed<DataTextureSource> CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) = 0;
@ -474,7 +474,7 @@ public:
virtual void ForcePresent() { }
widget::CompositorWidget* GetWidget() const { return mWidget; }
widget::CompositorWidgetProxy* GetWidget() const { return mWidget; }
virtual bool HasImageHostOverlays() { return false; }
@ -618,7 +618,7 @@ protected:
RefPtr<gfx::DrawTarget> mTarget;
gfx::IntRect mTargetBounds;
widget::CompositorWidget* mWidget;
widget::CompositorWidgetProxy* mWidget;
bool mIsDestroyed;

2
gfx/layers/basic/BasicCompositor.cpp
View File

@ -80,7 +80,7 @@ public:
bool mWrappingExistingData;
};
BasicCompositor::BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
BasicCompositor::BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
: Compositor(aWidget, aParent)
, mDidExternalComposition(false)
{

2
gfx/layers/basic/BasicCompositor.h
View File

@ -41,7 +41,7 @@ public:
class BasicCompositor : public Compositor
{
public:
explicit BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
explicit BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy *aWidget);
protected:
virtual ~BasicCompositor();

2
gfx/layers/basic/X11BasicCompositor.h
View File

@ -46,7 +46,7 @@ private:
class X11BasicCompositor : public BasicCompositor
{
public:
explicit X11BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
explicit X11BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
: BasicCompositor(aParent, aWidget)
{}

6
gfx/layers/d3d11/CompositorD3D11.cpp
View File

@ -22,7 +22,7 @@
#include "gfxVR.h"
#include "mozilla/gfx/StackArray.h"
#include "mozilla/Services.h"
#include "mozilla/widget/WinCompositorWidget.h"
#include "mozilla/widget/WinCompositorWidgetProxy.h"
#include "mozilla/EnumeratedArray.h"
#include "mozilla/Telemetry.h"
@ -160,7 +160,7 @@ private:
bool mInitOkay;
};
CompositorD3D11::CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
CompositorD3D11::CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
: Compositor(aWidget, aParent)
, mAttachments(nullptr)
, mHwnd(nullptr)
@ -216,7 +216,7 @@ CompositorD3D11::Initialize()
mFeatureLevel = mDevice->GetFeatureLevel();
mHwnd = mWidget->AsWindows()->GetHwnd();
mHwnd = mWidget->AsWindowsProxy()->GetHwnd();
memset(&mVSConstants, 0, sizeof(VertexShaderConstants));

2
gfx/layers/d3d11/CompositorD3D11.h
View File

@ -42,7 +42,7 @@ struct DeviceAttachmentsD3D11;
class CompositorD3D11 : public Compositor
{
public:
CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget);
~CompositorD3D11();
virtual CompositorD3D11* AsCompositorD3D11() override { return this; }

8
gfx/layers/d3d9/CompositorD3D9.cpp
View File

@ -17,14 +17,14 @@
#include "gfxPrefs.h"
#include "gfxCrashReporterUtils.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/widget/WinCompositorWidget.h"
#include "mozilla/widget/WinCompositorWidgetProxy.h"
namespace mozilla {
namespace layers {
using namespace mozilla::gfx;
CompositorD3D9::CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
CompositorD3D9::CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
: Compositor(aWidget, aParent)
, mDeviceResetCount(0)
, mFailedResetAttempts(0)
@ -47,7 +47,7 @@ CompositorD3D9::Initialize()
return false;
}
mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindows()->GetHwnd());
mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindowsProxy()->GetHwnd());
if (!mSwapChain) {
return false;
}
@ -590,7 +590,7 @@ CompositorD3D9::EnsureSwapChain()
MOZ_ASSERT(mDeviceManager, "Don't call EnsureSwapChain without a device manager");
if (!mSwapChain) {
mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindows()->GetHwnd());
mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindowsProxy()->GetHwnd());
// We could not create a swap chain, return false
if (!mSwapChain) {
// Check the state of the device too

2
gfx/layers/d3d9/CompositorD3D9.h
View File

@ -21,7 +21,7 @@ namespace layers {
class CompositorD3D9 : public Compositor
{
public:
CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget);
~CompositorD3D9();
virtual CompositorD3D9* AsCompositorD3D9() override { return this; }

29
gfx/layers/ipc/CompositorBridgeChild.cpp
View File

@ -29,10 +29,6 @@
#if defined(XP_WIN)
#include "WinUtils.h"
#endif
#include "mozilla/widget/CompositorWidget.h"
#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
# include "mozilla/widget/CompositorWidgetChild.h"
#endif
using mozilla::layers::LayerTransactionChild;
using mozilla::dom::TabChildBase;
@ -957,31 +953,6 @@ CompositorBridgeChild::DeallocShmem(ipc::Shmem& aShmem)
PCompositorBridgeChild::DeallocShmem(aShmem);
}
widget::PCompositorWidgetChild*
CompositorBridgeChild::AllocPCompositorWidgetChild(const CompositorWidgetInitData& aInitData)
{
// We send the constructor manually.
MOZ_CRASH("Should not be called");
return nullptr;
}
bool
CompositorBridgeChild::DeallocPCompositorWidgetChild(PCompositorWidgetChild* aActor)
{
#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
delete aActor;
return true;
#else
return false;
#endif
}
void
CompositorBridgeChild::ProcessingError(Result aCode, const char* aReason)
{
MOZ_CRASH("Processing error in CompositorBridgeChild");
}
} // namespace layers
} // namespace mozilla

5
gfx/layers/ipc/CompositorBridgeChild.h
View File

@ -193,13 +193,8 @@ public:
mozilla::ipc::Shmem* aShmem) override;
virtual void DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
PCompositorWidgetChild* AllocPCompositorWidgetChild(const CompositorWidgetInitData& aInitData) override;
bool DeallocPCompositorWidgetChild(PCompositorWidgetChild* aActor) override;
virtual ShmemAllocator* AsShmemAllocator() override { return this; }
void ProcessingError(Result aCode, const char* aReason) override;
private:
// Private destructor, to discourage deletion outside of Release():
virtual ~CompositorBridgeChild();

71
gfx/layers/ipc/CompositorBridgeParent.cpp
View File

@ -76,10 +76,6 @@
#include "ProfilerMarkers.h"
#endif
#include "mozilla/VsyncDispatcher.h"
#include "mozilla/widget/CompositorWidget.h"
#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
# include "mozilla/widget/CompositorWidgetParent.h"
#endif
#ifdef MOZ_WIDGET_GONK
#include "GeckoTouchDispatcher.h"
@ -237,13 +233,13 @@ CompositorVsyncScheduler::Observer::Destroy()
}
CompositorVsyncScheduler::CompositorVsyncScheduler(CompositorBridgeParent* aCompositorBridgeParent,
widget::CompositorWidget* aWidget)
widget::CompositorWidgetProxy* aWidgetProxy)
: mCompositorBridgeParent(aCompositorBridgeParent)
, mLastCompose(TimeStamp::Now())
, mIsObservingVsync(false)
, mNeedsComposite(0)
, mVsyncNotificationsSkipped(0)
, mCompositorVsyncDispatcher(aWidget->GetCompositorVsyncDispatcher())
, mCompositorVsyncDispatcher(aWidgetProxy->GetCompositorVsyncDispatcher())
, mCurrentCompositeTaskMonitor("CurrentCompositeTaskMonitor")
, mCurrentCompositeTask(nullptr)
, mSetNeedsCompositeMonitor("SetNeedsCompositeMonitor")
@ -586,13 +582,13 @@ CompositorLoop()
return CompositorThreadHolder::Loop();
}
CompositorBridgeParent::CompositorBridgeParent(widget::CompositorWidget* aWidget,
CompositorBridgeParent::CompositorBridgeParent(widget::CompositorWidgetProxy* aWidget,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
: CompositorBridgeParentIPCAllocator("CompositorBridgeParent")
, mWidget(aWidget)
, mWidgetProxy(aWidget)
, mIsTesting(false)
, mPendingTransaction(0)
, mPaused(false)
@ -703,7 +699,7 @@ CompositorBridgeParent::StopAndClearResources()
}
// After this point, it is no longer legal to access the widget.
mWidget = nullptr;
mWidgetProxy = nullptr;
}
bool
@ -1153,7 +1149,7 @@ CompositorBridgeParent::CompositeToTarget(DrawTarget* aTarget, const gfx::IntRec
// to local pages, hide every plugin associated with the window.
if (!hasRemoteContent && BrowserTabsRemoteAutostart() &&
mCachedPluginData.Length()) {
Unused << SendHideAllPlugins(GetWidget()->GetWidgetKey());
Unused << SendHideAllPlugins(GetWidgetProxy()->GetWidgetKey());
mCachedPluginData.Clear();
}
#endif
@ -1499,24 +1495,24 @@ CompositorBridgeParent::NewCompositor(const nsTArray<LayersBackend>& aBackendHin
RefPtr<Compositor> compositor;
if (aBackendHints[i] == LayersBackend::LAYERS_OPENGL) {
compositor = new CompositorOGL(this,
mWidget,
mWidgetProxy,
mEGLSurfaceSize.width,
mEGLSurfaceSize.height,
mUseExternalSurfaceSize);
} else if (aBackendHints[i] == LayersBackend::LAYERS_BASIC) {
#ifdef MOZ_WIDGET_GTK
if (gfxPlatformGtk::GetPlatform()->UseXRender()) {
compositor = new X11BasicCompositor(this, mWidget);
compositor = new X11BasicCompositor(this, mWidgetProxy);
} else
#endif
{
compositor = new BasicCompositor(this, mWidget);
compositor = new BasicCompositor(this, mWidgetProxy);
}
#ifdef XP_WIN
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D11) {
compositor = new CompositorD3D11(this, mWidget);
compositor = new CompositorD3D11(this, mWidgetProxy);
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D9) {
compositor = new CompositorD3D9(this, mWidget);
compositor = new CompositorD3D9(this, mWidgetProxy);
#endif
}
@ -1807,38 +1803,6 @@ CompositorBridgeParent::RequestNotifyLayerTreeCleared(uint64_t aLayersId, Compos
sIndirectLayerTrees[aLayersId].mLayerTreeClearedObserver = aObserver;
}
widget::PCompositorWidgetParent*
CompositorBridgeParent::AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData)
{
#if defined(MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING)
if (mWidget) {
// Should not create two widgets on the same compositor.
return nullptr;
}
widget::CompositorWidgetParent* widget =
new widget::CompositorWidgetParent(aInitData);
widget->AddRef();
// Sending the constructor acts as initialization as well.
mWidget = widget;
return widget;
#else
return nullptr;
#endif
}
bool
CompositorBridgeParent::DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor)
{
#if defined(MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING)
static_cast<widget::CompositorWidgetParent*>(aActor)->Release();
return true;
#else
return false;
#endif
}
/**
* This class handles layer updates pushed directly from child processes to
* the compositor thread. It's associated with a CompositorBridgeParent on the
@ -2018,15 +1982,6 @@ public:
Unused << SendParentAsyncMessages(aMessage);
}
PCompositorWidgetParent* AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData) override {
// Not allowed.
return nullptr;
}
bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override {
// Not allowed.
return false;
}
virtual CompositorBridgeParentIPCAllocator* AsCompositorBridgeParentIPCAllocator() override { return this; }
protected:
@ -2510,7 +2465,7 @@ CompositorBridgeParent::UpdatePluginWindowState(uint64_t aId)
return false;
}
uintptr_t parentWidget = GetWidget()->GetWidgetKey();
uintptr_t parentWidget = GetWidgetProxy()->GetWidgetKey();
// We will pass through here in cases where the previous shadow layer
// tree contained visible plugins and the new tree does not. All we need
@ -2595,7 +2550,7 @@ CompositorBridgeParent::HideAllPluginWindows()
return;
}
uintptr_t parentWidget = GetWidget()->GetWidgetKey();
uintptr_t parentWidget = GetWidgetProxy()->GetWidgetKey();
mDeferPluginWindows = true;
mPluginWindowsHidden = true;

13
gfx/layers/ipc/CompositorBridgeParent.h
View File

@ -33,10 +33,10 @@
#include "mozilla/layers/PCompositorBridgeParent.h"
#include "mozilla/layers/ShadowLayersManager.h" // for ShadowLayersManager
#include "mozilla/layers/APZTestData.h"
#include "mozilla/widget/CompositorWidget.h"
#include "nsISupportsImpl.h"
#include "ThreadSafeRefcountingWithMainThreadDestruction.h"
#include "mozilla/VsyncDispatcher.h"
#include "CompositorWidgetProxy.h"
class MessageLoop;
class nsIWidget;
@ -90,7 +90,7 @@ class CompositorVsyncScheduler
public:
explicit CompositorVsyncScheduler(CompositorBridgeParent* aCompositorBridgeParent,
widget::CompositorWidget* aWidget);
widget::CompositorWidgetProxy* aWidgetProxy);
#ifdef MOZ_WIDGET_GONK
// emulator-ics never trigger the display on/off, so compositor will always
@ -212,7 +212,7 @@ class CompositorBridgeParent final : public PCompositorBridgeParent,
friend class gfx::GPUProcessManager;
public:
explicit CompositorBridgeParent(widget::CompositorWidget* aWidget,
explicit CompositorBridgeParent(widget::CompositorWidgetProxy* aWidget,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
@ -305,9 +305,6 @@ public:
virtual void DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
PCompositorWidgetParent* AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData) override;
bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override;
virtual base::ProcessId GetChildProcessId() override
{
return OtherPid();
@ -467,7 +464,7 @@ public:
float ComputeRenderIntegrity();
widget::CompositorWidget* GetWidget() { return mWidget; }
widget::CompositorWidgetProxy* GetWidgetProxy() { return mWidgetProxy; }
void ForceComposeToTarget(gfx::DrawTarget* aTarget, const gfx::IntRect* aRect = nullptr);
@ -589,7 +586,7 @@ protected:
RefPtr<LayerManagerComposite> mLayerManager;
RefPtr<Compositor> mCompositor;
RefPtr<AsyncCompositionManager> mCompositionManager;
widget::CompositorWidget* mWidget;
widget::CompositorWidgetProxy* mWidgetProxy;
TimeStamp mTestTime;
bool mIsTesting;

5
gfx/layers/ipc/PCompositorBridge.ipdl
View File

@ -7,10 +7,8 @@
include LayersSurfaces;
include LayersMessages;
include PlatformWidgetTypes;
include protocol PBrowser;
include protocol PCompositable;
include protocol PCompositorWidget;
include protocol PImageContainer;
include protocol PLayer;
include protocol PLayerTransaction;
@ -49,7 +47,6 @@ sync protocol PCompositorBridge
// A Compositor manages a single Layer Manager (PLayerTransaction)
manages PLayerTransaction;
manages PTexture;
manages PCompositorWidget;
child:
// The child should invalidate retained layers. This is used for local
@ -106,8 +103,6 @@ child:
async ParentAsyncMessages(AsyncParentMessageData[] aMessages);
parent:
async PCompositorWidget(CompositorWidgetInitData aInitData);
/**
* Confirmation callback for UpdatePluginConfigurations and HideAllPlugins.
*/

4
gfx/layers/opengl/CompositorOGL.cpp
View File

@ -84,7 +84,7 @@ CompositorOGL::BindBackdrop(ShaderProgramOGL* aProgram, GLuint aBackdrop, GLenum
}
CompositorOGL::CompositorOGL(CompositorBridgeParent* aParent,
widget::CompositorWidget* aWidget,
widget::CompositorWidgetProxy* aWidget,
int aSurfaceWidth, int aSurfaceHeight,
bool aUseExternalSurfaceSize)
: Compositor(aWidget, aParent)
@ -618,7 +618,7 @@ CompositorOGL::GetCurrentRenderTarget() const
static GLenum
GetFrameBufferInternalFormat(GLContext* gl,
GLuint aFrameBuffer,
mozilla::widget::CompositorWidget* aWidget)
mozilla::widget::CompositorWidgetProxy* aWidget)
{
if (aFrameBuffer == 0) { // default framebuffer
return aWidget->GetGLFrameBufferFormat();

2
gfx/layers/opengl/CompositorOGL.h
View File

@ -193,7 +193,7 @@ class CompositorOGL final : public Compositor
std::map<ShaderConfigOGL, ShaderProgramOGL*> mPrograms;
public:
explicit CompositorOGL(CompositorBridgeParent* aParent,
widget::CompositorWidget* aWidget,
widget::CompositorWidgetProxy* aWidget,
int aSurfaceWidth = -1, int aSurfaceHeight = -1,
bool aUseExternalSurfaceSize = false);

11
gfx/tests/gtest/TestCompositor.cpp
View File

@ -15,7 +15,6 @@
#include "mozilla/layers/CompositorOGL.h" // for CompositorOGL
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/LayerManagerComposite.h"
#include "mozilla/widget/InProcessCompositorWidget.h"
#include "nsBaseWidget.h"
#include "GLContext.h"
#include "GLContextProvider.h"
@ -100,21 +99,21 @@ NS_IMPL_ISUPPORTS_INHERITED0(MockWidget, nsBaseWidget)
struct LayerManagerData {
RefPtr<MockWidget> mWidget;
RefPtr<Compositor> mCompositor;
RefPtr<widget::CompositorWidget> mCompositorWidget;
RefPtr<widget::CompositorWidgetProxy> mCompositorWidgetProxy;
RefPtr<LayerManagerComposite> mLayerManager;
LayerManagerData(Compositor* compositor,
MockWidget* widget,
widget::CompositorWidget* aWidget,
widget::CompositorWidgetProxy* aProxy,
LayerManagerComposite* layerManager)
: mWidget(widget)
, mCompositor(compositor)
, mCompositorWidget(aWidget)
, mCompositorWidgetProxy(aProxy)
, mLayerManager(layerManager)
{}
};
static already_AddRefed<Compositor> CreateTestCompositor(LayersBackend backend, widget::CompositorWidget* widget)
static already_AddRefed<Compositor> CreateTestCompositor(LayersBackend backend, widget::CompositorWidgetProxy* widget)
{
gfxPrefs::GetSingleton();
@ -158,7 +157,7 @@ static std::vector<LayerManagerData> GetLayerManagers(std::vector<LayersBackend>
auto backend = aBackends[i];
RefPtr<MockWidget> widget = new MockWidget();
RefPtr<widget::CompositorWidget> proxy = new widget::InProcessCompositorWidget(widget);
RefPtr<widget::CompositorWidgetProxy> proxy = widget->NewCompositorWidgetProxy();
RefPtr<Compositor> compositor = CreateTestCompositor(backend, proxy);
RefPtr<LayerManagerComposite> layerManager = new LayerManagerComposite(compositor);

74
widget/CompositorWidget.cpp
View File

@ -1,74 +0,0 @@
/* 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/. */
#include "CompositorWidget.h"
#include "GLConsts.h"
#include "nsBaseWidget.h"
#include "VsyncDispatcher.h"
namespace mozilla {
namespace widget {
CompositorWidget::~CompositorWidget()
{
}
already_AddRefed<gfx::DrawTarget>
CompositorWidget::StartRemoteDrawing()
{
return nullptr;
}
void
CompositorWidget::CleanupRemoteDrawing()
{
mLastBackBuffer = nullptr;
}
already_AddRefed<gfx::DrawTarget>
CompositorWidget::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect)
{
MOZ_ASSERT(aScreenTarget);
gfx::SurfaceFormat format =
aScreenTarget->GetFormat() == gfx::SurfaceFormat::B8G8R8X8 ? gfx::SurfaceFormat::B8G8R8X8 : gfx::SurfaceFormat::B8G8R8A8;
gfx::IntSize size = aRect.ToUnknownRect().Size();
gfx::IntSize clientSize(GetClientSize().ToUnknownSize());
RefPtr<gfx::DrawTarget> target;
// Re-use back buffer if possible
if (mLastBackBuffer &&
mLastBackBuffer->GetBackendType() == aScreenTarget->GetBackendType() &&
mLastBackBuffer->GetFormat() == format &&
size <= mLastBackBuffer->GetSize() &&
mLastBackBuffer->GetSize() <= clientSize) {
target = mLastBackBuffer;
target->SetTransform(gfx::Matrix());
if (!aClearRect.IsEmpty()) {
gfx::IntRect clearRect = aClearRect.ToUnknownRect() - aRect.ToUnknownRect().TopLeft();
target->ClearRect(gfx::Rect(clearRect.x, clearRect.y, clearRect.width, clearRect.height));
}
} else {
target = aScreenTarget->CreateSimilarDrawTarget(size, format);
mLastBackBuffer = target;
}
return target.forget();
}
already_AddRefed<gfx::SourceSurface>
CompositorWidget::EndBackBufferDrawing()
{
RefPtr<gfx::SourceSurface> surface = mLastBackBuffer ? mLastBackBuffer->Snapshot() : nullptr;
return surface.forget();
}
uint32_t
CompositorWidget::GetGLFrameBufferFormat()
{
return LOCAL_GL_RGBA;
}
} // namespace widget
} // namespace mozilla

186
widget/CompositorWidgetProxy.cpp Normal file
View File

@ -0,0 +1,186 @@
/* 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/. */
#include "CompositorWidgetProxy.h"
#include "GLConsts.h"
#include "nsBaseWidget.h"
#include "VsyncDispatcher.h"
namespace mozilla {
namespace widget {
CompositorWidgetProxy::~CompositorWidgetProxy()
{
}
already_AddRefed<gfx::DrawTarget>
CompositorWidgetProxy::StartRemoteDrawing()
{
return nullptr;
}
void
CompositorWidgetProxy::CleanupRemoteDrawing()
{
mLastBackBuffer = nullptr;
}
already_AddRefed<gfx::DrawTarget>
CompositorWidgetProxy::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect)
{
MOZ_ASSERT(aScreenTarget);
gfx::SurfaceFormat format =
aScreenTarget->GetFormat() == gfx::SurfaceFormat::B8G8R8X8 ? gfx::SurfaceFormat::B8G8R8X8 : gfx::SurfaceFormat::B8G8R8A8;
gfx::IntSize size = aRect.ToUnknownRect().Size();
gfx::IntSize clientSize(GetClientSize().ToUnknownSize());
RefPtr<gfx::DrawTarget> target;
// Re-use back buffer if possible
if (mLastBackBuffer &&
mLastBackBuffer->GetBackendType() == aScreenTarget->GetBackendType() &&
mLastBackBuffer->GetFormat() == format &&
size <= mLastBackBuffer->GetSize() &&
mLastBackBuffer->GetSize() <= clientSize) {
target = mLastBackBuffer;
target->SetTransform(gfx::Matrix());
if (!aClearRect.IsEmpty()) {
gfx::IntRect clearRect = aClearRect.ToUnknownRect() - aRect.ToUnknownRect().TopLeft();
target->ClearRect(gfx::Rect(clearRect.x, clearRect.y, clearRect.width, clearRect.height));
}
} else {
target = aScreenTarget->CreateSimilarDrawTarget(size, format);
mLastBackBuffer = target;
}
return target.forget();
}
already_AddRefed<gfx::SourceSurface>
CompositorWidgetProxy::EndBackBufferDrawing()
{
RefPtr<gfx::SourceSurface> surface = mLastBackBuffer ? mLastBackBuffer->Snapshot() : nullptr;
return surface.forget();
}
uint32_t
CompositorWidgetProxy::GetGLFrameBufferFormat()
{
return LOCAL_GL_RGBA;
}
CompositorWidgetProxyWrapper::CompositorWidgetProxyWrapper(nsBaseWidget* aWidget)
: mWidget(aWidget)
{
}
bool
CompositorWidgetProxyWrapper::PreRender(layers::LayerManagerComposite* aManager)
{
return mWidget->PreRender(aManager);
}
void
CompositorWidgetProxyWrapper::PostRender(layers::LayerManagerComposite* aManager)
{
mWidget->PostRender(aManager);
}
void
CompositorWidgetProxyWrapper::DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowUnderlay(aManager, aRect);
}
void
CompositorWidgetProxyWrapper::DrawWindowOverlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowOverlay(aManager, aRect);
}
already_AddRefed<gfx::DrawTarget>
CompositorWidgetProxyWrapper::StartRemoteDrawing()
{
return mWidget->StartRemoteDrawing();
}
already_AddRefed<gfx::DrawTarget>
CompositorWidgetProxyWrapper::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
layers::BufferMode* aBufferMode)
{
return mWidget->StartRemoteDrawingInRegion(aInvalidRegion, aBufferMode);
}
void
CompositorWidgetProxyWrapper::EndRemoteDrawing()
{
mWidget->EndRemoteDrawing();
}
void
CompositorWidgetProxyWrapper::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
LayoutDeviceIntRegion& aInvalidRegion)
{
mWidget->EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion);
}
void
CompositorWidgetProxyWrapper::CleanupRemoteDrawing()
{
mWidget->CleanupRemoteDrawing();
}
void
CompositorWidgetProxyWrapper::CleanupWindowEffects()
{
mWidget->CleanupWindowEffects();
}
bool
CompositorWidgetProxyWrapper::InitCompositor(layers::Compositor* aCompositor)
{
return mWidget->InitCompositor(aCompositor);
}
LayoutDeviceIntSize
CompositorWidgetProxyWrapper::GetClientSize()
{
return mWidget->GetClientSize();
}
uint32_t
CompositorWidgetProxyWrapper::GetGLFrameBufferFormat()
{
return mWidget->GetGLFrameBufferFormat();
}
layers::Composer2D*
CompositorWidgetProxyWrapper::GetComposer2D()
{
return mWidget->GetComposer2D();
}
uintptr_t
CompositorWidgetProxyWrapper::GetWidgetKey()
{
return reinterpret_cast<uintptr_t>(mWidget);
}
nsIWidget*
CompositorWidgetProxyWrapper::RealWidget()
{
return mWidget;
}
already_AddRefed<CompositorVsyncDispatcher>
CompositorWidgetProxyWrapper::GetCompositorVsyncDispatcher()
{
RefPtr<CompositorVsyncDispatcher> cvd = mWidget->GetCompositorVsyncDispatcher();
return cvd.forget();
}
} // namespace widget
} // namespace mozilla

84
widget/CompositorWidget.h → widget/CompositorWidgetProxy.h
View File

@ -2,8 +2,8 @@
* 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__
#ifndef mozilla_widget_CompositorWidgetProxy_h__
#define mozilla_widget_CompositorWidgetProxy_h__
#include "nsISupports.h"
#include "mozilla/RefPtr.h"
@ -28,42 +28,15 @@ class SourceSurface;
} // namespace gfx
namespace widget {
class WinCompositorWidget;
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 CompositorWidgetDelegate;
// Platforms that support out-of-process widgets.
#if defined(XP_WIN)
// CompositorWidgetParent should implement CompositorWidget and
// PCompositorWidgetParent.
class CompositorWidgetParent;
// CompositorWidgetChild should implement CompositorWidgetDelegate and
// PCompositorWidgetChild.
class CompositorWidgetChild;
# define MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
#endif
class WinCompositorWidgetProxy;
/**
* Access to a widget from the compositor is restricted to these methods.
*/
class CompositorWidget
class CompositorWidgetProxy
{
public:
NS_INLINE_DECL_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, nsIWidget* aWidget);
NS_INLINE_DECL_REFCOUNTING(mozilla::widget::CompositorWidgetProxy)
/**
* Called before rendering using OMTC. Returns false when the widget is
@ -227,24 +200,53 @@ public:
*/
virtual already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() = 0;
virtual WinCompositorWidget* AsWindows() {
return nullptr;
}
/**
* Return the platform-specific delegate for the widget, if any.
*/
virtual CompositorWidgetDelegate* AsDelegate() {
virtual WinCompositorWidgetProxy* AsWindowsProxy() {
return nullptr;
}
protected:
virtual ~CompositorWidget();
virtual ~CompositorWidgetProxy();
// Back buffer of BasicCompositor
RefPtr<gfx::DrawTarget> mLastBackBuffer;
};
// This version of CompositorWidgetProxy implements a wrapper around
// nsBaseWidget.
class CompositorWidgetProxyWrapper : public CompositorWidgetProxy
{
public:
explicit CompositorWidgetProxyWrapper(nsBaseWidget* aWidget);
virtual bool PreRender(layers::LayerManagerComposite* aManager) override;
virtual void PostRender(layers::LayerManagerComposite* aManager) override;
virtual void DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect) override;
virtual void DrawWindowOverlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect) override;
virtual already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
virtual already_AddRefed<gfx::DrawTarget>
StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
layers::BufferMode* aBufferMode) override;
virtual void EndRemoteDrawing() override;
virtual void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
LayoutDeviceIntRegion& aInvalidRegion) override;
virtual void CleanupRemoteDrawing() override;
virtual void CleanupWindowEffects() override;
virtual bool InitCompositor(layers::Compositor* aCompositor) override;
virtual LayoutDeviceIntSize GetClientSize() override;
virtual uint32_t GetGLFrameBufferFormat() override;
virtual layers::Composer2D* GetComposer2D() override;
virtual already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() override;
virtual uintptr_t GetWidgetKey() override;
// If you can override this method, inherit from CompositorWidgetProxy instead.
nsIWidget* RealWidget() override;
private:
nsBaseWidget* mWidget;
};
} // namespace widget
} // namespace mozilla

136
widget/InProcessCompositorWidget.cpp
View File

@ -1,136 +0,0 @@
/* 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/. */
#include "InProcessCompositorWidget.h"
#include "nsBaseWidget.h"
namespace mozilla {
namespace widget {
// Platforms with no OOP compositor process support use
// InProcessCompositorWidget by default.
#if !defined(MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING)
/* static */ RefPtr<CompositorWidget>
CompositorWidget::CreateLocal(const CompositorWidgetInitData& aInitData, nsIWidget* aWidget)
{
MOZ_ASSERT(aWidget);
return new InProcessCompositorWidget(static_cast<nsBaseWidget*>(aWidget));
}
#endif
InProcessCompositorWidget::InProcessCompositorWidget(nsBaseWidget* aWidget)
: mWidget(aWidget)
{
}
bool
InProcessCompositorWidget::PreRender(layers::LayerManagerComposite* aManager)
{
return mWidget->PreRender(aManager);
}
void
InProcessCompositorWidget::PostRender(layers::LayerManagerComposite* aManager)
{
mWidget->PostRender(aManager);
}
void
InProcessCompositorWidget::DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowUnderlay(aManager, aRect);
}
void
InProcessCompositorWidget::DrawWindowOverlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowOverlay(aManager, aRect);
}
already_AddRefed<gfx::DrawTarget>
InProcessCompositorWidget::StartRemoteDrawing()
{
return mWidget->StartRemoteDrawing();
}
already_AddRefed<gfx::DrawTarget>
InProcessCompositorWidget::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
layers::BufferMode* aBufferMode)
{
return mWidget->StartRemoteDrawingInRegion(aInvalidRegion, aBufferMode);
}
void
InProcessCompositorWidget::EndRemoteDrawing()
{
mWidget->EndRemoteDrawing();
}
void
InProcessCompositorWidget::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
LayoutDeviceIntRegion& aInvalidRegion)
{
mWidget->EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion);
}
void
InProcessCompositorWidget::CleanupRemoteDrawing()
{
mWidget->CleanupRemoteDrawing();
}
void
InProcessCompositorWidget::CleanupWindowEffects()
{
mWidget->CleanupWindowEffects();
}
bool
InProcessCompositorWidget::InitCompositor(layers::Compositor* aCompositor)
{
return mWidget->InitCompositor(aCompositor);
}
LayoutDeviceIntSize
InProcessCompositorWidget::GetClientSize()
{
return mWidget->GetClientSize();
}
uint32_t
InProcessCompositorWidget::GetGLFrameBufferFormat()
{
return mWidget->GetGLFrameBufferFormat();
}
layers::Composer2D*
InProcessCompositorWidget::GetComposer2D()
{
return mWidget->GetComposer2D();
}
uintptr_t
InProcessCompositorWidget::GetWidgetKey()
{
return reinterpret_cast<uintptr_t>(mWidget);
}
nsIWidget*
InProcessCompositorWidget::RealWidget()
{
return mWidget;
}
already_AddRefed<CompositorVsyncDispatcher>
InProcessCompositorWidget::GetCompositorVsyncDispatcher()
{
RefPtr<CompositorVsyncDispatcher> cvd = mWidget->GetCompositorVsyncDispatcher();
return cvd.forget();
}
} // namespace widget
} // namespace mozilla

52
widget/InProcessCompositorWidget.h
View File

@ -1,52 +0,0 @@
/* 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_InProcessCompositorWidget_h__
#define mozilla_widget_InProcessCompositorWidget_h__
#include "CompositorWidget.h"
namespace mozilla {
namespace widget {
// This version of CompositorWidget implements a wrapper around
// nsBaseWidget.
class InProcessCompositorWidget : public CompositorWidget
{
public:
explicit InProcessCompositorWidget(nsBaseWidget* aWidget);
virtual bool PreRender(layers::LayerManagerComposite* aManager) override;
virtual void PostRender(layers::LayerManagerComposite* aManager) override;
virtual void DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect) override;
virtual void DrawWindowOverlay(layers::LayerManagerComposite* aManager,
LayoutDeviceIntRect aRect) override;
virtual already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
virtual already_AddRefed<gfx::DrawTarget>
StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
layers::BufferMode* aBufferMode) override;
virtual void EndRemoteDrawing() override;
virtual void EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
LayoutDeviceIntRegion& aInvalidRegion) override;
virtual void CleanupRemoteDrawing() override;
virtual void CleanupWindowEffects() override;
virtual bool InitCompositor(layers::Compositor* aCompositor) override;
virtual LayoutDeviceIntSize GetClientSize() override;
virtual uint32_t GetGLFrameBufferFormat() override;
virtual layers::Composer2D* GetComposer2D() override;
virtual already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() override;
virtual uintptr_t GetWidgetKey() override;
// If you can override this method, inherit from CompositorWidget instead.
nsIWidget* RealWidget() override;
private:
nsBaseWidget* mWidget;
};
} // namespace widget
} // namespace mozilla
#endif

24
widget/PCompositorWidget.ipdl
View File

@ -1,24 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=99: */
/* 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/. */
include protocol PCompositorBridge;
// This file is a stub, for platforms that do not yet support out-of-process
// compositing or do not need specialized types to do so.
namespace mozilla {
namespace widget {
sync protocol PCompositorWidget
{
manager PCompositorBridge;
parent:
async __delete__();
};
} // namespace widget
} // namespace mozilla

18
widget/PlatformWidgetTypes.ipdlh
View File

@ -1,18 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=99: */
/* 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/. */
// This file is a stub, for platforms that do not yet support out-of-process
// compositing or do not need specialized types to do so.
namespace mozilla {
namespace widget {
struct CompositorWidgetInitData
{
};
} // namespace widget
} // namespace mozilla

6
widget/PuppetWidget.h
View File

@ -280,6 +280,12 @@ protected:
virtual nsresult NotifyIMEInternal(
const IMENotification& aIMENotification) override;
// PuppetWidgets do not create compositors.
widget::CompositorWidgetProxy* NewCompositorWidgetProxy() override {
MOZ_ASSERT_UNREACHABLE("PuppetWidgets should not have widget proxies");
return nullptr;
}
private:
nsresult Paint();

4
widget/cocoa/nsCocoaWindow.h
View File

@ -354,6 +354,10 @@ public:
NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent) override;
CompositorWidgetProxy* NewCompositorWidgetProxy() override {
return nullptr;
}
protected:
virtual ~nsCocoaWindow();

17
widget/moz.build
View File

@ -88,6 +88,7 @@ XPIDL_SOURCES += [
XPIDL_MODULE = 'widget'
EXPORTS += [
'CompositorWidgetProxy.h',
'GfxDriverInfo.h',
'GfxInfoBase.h',
'GfxInfoCollector.h',
@ -128,21 +129,18 @@ EXPORTS.mozilla += [
]
EXPORTS.mozilla.widget += [
'CompositorWidget.h',
'IMEData.h',
'InProcessCompositorWidget.h',
'PuppetBidiKeyboard.h',
'WidgetMessageUtils.h',
]
UNIFIED_SOURCES += [
'CompositorWidget.cpp',
'CompositorWidgetProxy.cpp',
'ContentCache.cpp',
'GfxDriverInfo.cpp',
'GfxInfoBase.cpp',
'GfxInfoCollector.cpp',
'GfxInfoWebGL.cpp',
'InProcessCompositorWidget.cpp',
'InputData.cpp',
'nsBaseAppShell.cpp',
'nsBaseScreen.cpp',
@ -242,17 +240,6 @@ LOCAL_INCLUDES += [
'/widget',
]
if toolkit == 'windows':
IPDL_SOURCES = [
'windows/PCompositorWidget.ipdl',
'windows/PlatformWidgetTypes.ipdlh',
]
else:
IPDL_SOURCES = [
'PCompositorWidget.ipdl',
'PlatformWidgetTypes.ipdlh',
]
widget_dir = toolkit
if widget_dir in ('gtk3', 'gtk2'):
# gtk3 shares includes with gtk2

19
widget/nsBaseWidget.cpp
View File

@ -171,7 +171,6 @@ nsBaseWidget::nsBaseWidget()
, mSizeMode(nsSizeMode_Normal)
, mPopupLevel(ePopupLevelTop)
, mPopupType(ePopupTypeAny)
, mCompositorWidgetDelegate(nullptr)
, mUpdateCursor(true)
, mUseAttachedEvents(false)
, mIMEHasFocus(false)
@ -274,13 +273,16 @@ void nsBaseWidget::DestroyCompositor()
if (mCompositorSession) {
ReleaseContentController();
mAPZC = nullptr;
mCompositorWidgetDelegate = nullptr;
mCompositorBridgeChild = nullptr;
// XXX CompositorBridgeChild and CompositorBridgeParent might be re-created in
// ClientLayerManager destructor. See bug 1133426.
RefPtr<CompositorSession> session = mCompositorSession.forget();
session->Shutdown();
// Widget is used in CompositorBridgeParent, so we can't release it until
// it has acknowledged shutdown.
mCompositorWidgetProxy = nullptr;
}
// Can have base widgets that are things like tooltips
@ -1304,18 +1306,21 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight)
CreateCompositorVsyncDispatcher();
if (!mCompositorWidgetProxy) {
mCompositorWidgetProxy = NewCompositorWidgetProxy();
}
RefPtr<ClientLayerManager> lm = new ClientLayerManager(this);
gfx::GPUProcessManager* gpu = gfx::GPUProcessManager::Get();
mCompositorSession = gpu->CreateTopLevelCompositor(
this,
mCompositorWidgetProxy,
lm,
GetDefaultScale(),
UseAPZ(),
UseExternalCompositingSurface(),
gfx::IntSize(aWidth, aHeight));
mCompositorBridgeChild = mCompositorSession->GetCompositorBridgeChild();
mCompositorWidgetDelegate = mCompositorSession->GetCompositorWidgetDelegate();
mAPZC = mCompositorSession->GetAPZCTreeManager();
if (mAPZC) {
@ -1419,6 +1424,12 @@ nsBaseWidget::GetGLFrameBufferFormat()
return LOCAL_GL_RGBA;
}
mozilla::widget::CompositorWidgetProxy*
nsBaseWidget::NewCompositorWidgetProxy()
{
return new mozilla::widget::CompositorWidgetProxyWrapper(this);
}
//-------------------------------------------------------------------------
//
// Destroy the window

17
widget/nsBaseWidget.h
View File

@ -21,6 +21,7 @@
#include "nsIWidgetListener.h"
#include "nsPIDOMWindow.h"
#include "nsWeakReference.h"
#include "CompositorWidgetProxy.h"
#include <algorithm>
class nsIContent;
class nsAutoRollup;
@ -49,11 +50,6 @@ class CompositorSession;
struct ScrollableLayerGuid;
} // namespace layers
namespace widget {
class CompositorWidgetDelegate;
class InProcessCompositorWidget;
} // namespace widget
class CompositorVsyncDispatcher;
} // namespace mozilla
@ -99,7 +95,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference
{
friend class nsAutoRollup;
friend class DispatchWheelEventOnMainThread;
friend class mozilla::widget::InProcessCompositorWidget;
friend class mozilla::widget::CompositorWidgetProxyWrapper;
protected:
typedef base::Thread Thread;
@ -116,7 +112,7 @@ protected:
typedef mozilla::CSSIntRect CSSIntRect;
typedef mozilla::CSSRect CSSRect;
typedef mozilla::ScreenRotation ScreenRotation;
typedef mozilla::widget::CompositorWidgetDelegate CompositorWidgetDelegate;
typedef mozilla::widget::CompositorWidgetProxy CompositorWidgetProxy;
typedef mozilla::layers::CompositorSession CompositorSession;
virtual ~nsBaseWidget();
@ -355,8 +351,11 @@ public:
void Shutdown();
// Return a new CompositorWidgetProxy for this widget.
virtual CompositorWidgetProxy* NewCompositorWidgetProxy();
protected:
// These are methods for CompositorWidgetWrapper, and should only be
// These are methods for CompositorWidgetProxyWrapper, and should only be
// accessed from that class. Derived widgets can choose which methods to
// implement, or none if supporting out-of-process compositing.
virtual bool PreRender(mozilla::layers::LayerManagerComposite* aManager) {
@ -589,7 +588,7 @@ protected:
nsPopupType mPopupType;
SizeConstraints mSizeConstraints;
CompositorWidgetDelegate* mCompositorWidgetDelegate;
RefPtr<CompositorWidgetProxy> mCompositorWidgetProxy;
bool mUpdateCursor;
bool mUseAttachedEvents;

7
widget/nsIWidget.h
View File

@ -65,8 +65,6 @@ class SourceSurface;
namespace widget {
class TextEventDispatcher;
class TextEventDispatcherListener;
class CompositorWidget;
class CompositorWidgetInitData;
} // namespace widget
} // namespace mozilla
@ -1633,11 +1631,6 @@ class nsIWidget : public nsISupports
virtual void StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics) = 0;
// If this widget supports out-of-process compositing, it can override
// this method to provide additional information to the compositor.
virtual void GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData)
{}
private:
class LongTapInfo
{

62
widget/windows/CompositorWidgetChild.cpp
View File

@ -1,62 +0,0 @@
/* -*- 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/. */
#include "CompositorWidgetChild.h"
#include "mozilla/unused.h"
namespace mozilla {
namespace widget {
CompositorWidgetChild::CompositorWidgetChild(nsIWidget* aWidget)
{
}
CompositorWidgetChild::~CompositorWidgetChild()
{
}
void
CompositorWidgetChild::EnterPresentLock()
{
Unused << SendEnterPresentLock();
}
void
CompositorWidgetChild::LeavePresentLock()
{
Unused << SendLeavePresentLock();
}
void
CompositorWidgetChild::OnDestroyWindow()
{
}
void
CompositorWidgetChild::UpdateTransparency(nsTransparencyMode aMode)
{
Unused << SendUpdateTransparency(static_cast<int32_t>(aMode));
}
void
CompositorWidgetChild::ClearTransparentWindow()
{
Unused << SendClearTransparentWindow();
}
void
CompositorWidgetChild::ResizeTransparentWindow(const gfx::IntSize& aSize)
{
Unused << SendResizeTransparentWindow(aSize);
}
HDC CompositorWidgetChild::GetTransparentDC() const
{
// Not supported in out-of-process mode.
return nullptr;
}
} // namespace widget
} // namespace mozilla

35
widget/windows/CompositorWidgetChild.h
View File

@ -1,35 +0,0 @@
/* -*- 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_CompositorWidgetChild_h
#define widget_windows_CompositorWidgetChild_h
#include "WinCompositorWidget.h"
#include "mozilla/widget/PCompositorWidgetChild.h"
namespace mozilla {
namespace widget {
class CompositorWidgetChild final
: public PCompositorWidgetChild,
public CompositorWidgetDelegate
{
public:
CompositorWidgetChild(nsIWidget* aWidget);
~CompositorWidgetChild() override;
void EnterPresentLock() override;
void LeavePresentLock() override;
void OnDestroyWindow() override;
void UpdateTransparency(nsTransparencyMode aMode) override;
void ClearTransparentWindow() override;
void ResizeTransparentWindow(const gfx::IntSize& aSize) override;
HDC GetTransparentDC() const override;
};
} // namespace widget
} // namespace mozilla
#endif // widget_windows_CompositorWidgetChild_h

61
widget/windows/CompositorWidgetParent.cpp
View File

@ -1,61 +0,0 @@
/* -*- 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/. */
#include "CompositorWidgetParent.h"
namespace mozilla {
namespace widget {
CompositorWidgetParent::CompositorWidgetParent(const CompositorWidgetInitData& aInitData)
: WinCompositorWidget(aInitData)
{
}
CompositorWidgetParent::~CompositorWidgetParent()
{
}
bool
CompositorWidgetParent::RecvEnterPresentLock()
{
EnterPresentLock();
return true;
}
bool
CompositorWidgetParent::RecvLeavePresentLock()
{
LeavePresentLock();
return true;
}
bool
CompositorWidgetParent::RecvUpdateTransparency(const int32_t& aMode)
{
UpdateTransparency(static_cast<nsTransparencyMode>(aMode));
return true;
}
bool
CompositorWidgetParent::RecvClearTransparentWindow()
{
ClearTransparentWindow();
return true;
}
bool
CompositorWidgetParent::RecvResizeTransparentWindow(const IntSize& aSize)
{
ResizeTransparentWindow(aSize);
return true;
}
void
CompositorWidgetParent::ActorDestroy(ActorDestroyReason aWhy)
{
}
} // namespace widget
} // namespace mozilla

34
widget/windows/CompositorWidgetParent.h
View File

@ -1,34 +0,0 @@
/* -*- 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_WinCompositorWidget_h__
#define _widget_windows_WinCompositorWidget_h__
#include "WinCompositorWidget.h"
#include "mozilla/widget/PCompositorWidgetParent.h"
namespace mozilla {
namespace widget {
class CompositorWidgetParent final
: public PCompositorWidgetParent,
public WinCompositorWidget
{
public:
CompositorWidgetParent(const CompositorWidgetInitData& aInitData);
~CompositorWidgetParent() override;
bool RecvEnterPresentLock() override;
bool RecvLeavePresentLock() override;
bool RecvUpdateTransparency(const int32_t& aMode) override;
bool RecvClearTransparentWindow() override;
bool RecvResizeTransparentWindow(const IntSize& aSize) override;
void ActorDestroy(ActorDestroyReason aWhy) override;
};
} // namespace widget
} // namespace mozilla
#endif // _widget_windows_WinCompositorWidget_h__

28
widget/windows/PCompositorWidget.ipdl
View File

@ -1,28 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=99: */
/* 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/. */
include protocol PCompositorBridge;
using mozilla::gfx::IntSize from "mozilla/gfx/Point.h";
namespace mozilla {
namespace widget {
sync protocol PCompositorWidget
{
manager PCompositorBridge;
parent:
sync EnterPresentLock();
sync LeavePresentLock();
async UpdateTransparency(int32_t aMode);
sync ClearTransparentWindow();
sync ResizeTransparentWindow(IntSize aSize);
async __delete__();
};
} // namespace widget
} // namespace mozilla

23
widget/windows/PlatformWidgetTypes.ipdlh
View File

@ -1,23 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=99: */
/* 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/. */
// This file is a stub, for platforms that do not yet support out-of-process
// compositing or do not need specialized types to do so.
using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h";
namespace mozilla {
namespace widget {
struct CompositorWidgetInitData
{
WindowsHandle hWnd;
uintptr_t widgetKey;
int32_t transparencyMode;
};
} // namespace widget
} // namespace mozilla

82
widget/windows/WinCompositorWidget.cpp → widget/windows/WinCompositorWidgetProxy.cpp
View File

@ -3,45 +3,39 @@
* 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/. */
#include "WinCompositorWidget.h"
#include "WinCompositorWidgetProxy.h"
#include "nsWindow.h"
#include "VsyncDispatcher.h"
#include "mozilla/gfx/Point.h"
#include "mozilla/widget/PlatformWidgetTypes.h"
namespace mozilla {
namespace widget {
using namespace mozilla::gfx;
/* static */ RefPtr<CompositorWidget>
CompositorWidget::CreateLocal(const CompositorWidgetInitData& aInitData, nsIWidget* aWidget)
{
return new WinCompositorWidget(aInitData, static_cast<nsWindow*>(aWidget));
}
WinCompositorWidget::WinCompositorWidget(const CompositorWidgetInitData& aInitData,
nsWindow* aWindow)
WinCompositorWidgetProxy::WinCompositorWidgetProxy(nsWindow* aWindow)
: mWindow(aWindow),
mWidgetKey(aInitData.widgetKey()),
mWnd(reinterpret_cast<HWND>(aInitData.hWnd())),
mTransparencyMode(static_cast<nsTransparencyMode>(aInitData.transparencyMode())),
mWidgetKey(reinterpret_cast<uintptr_t>(aWindow)),
mWnd(reinterpret_cast<HWND>(aWindow->GetNativeData(NS_NATIVE_WINDOW))),
mTransparencyMode(aWindow->GetTransparencyMode()),
mMemoryDC(nullptr),
mCompositeDC(nullptr),
mLockedBackBufferData(nullptr)
{
MOZ_ASSERT(aWindow);
MOZ_ASSERT(!aWindow->Destroyed());
MOZ_ASSERT(mWnd && ::IsWindow(mWnd));
}
void
WinCompositorWidget::OnDestroyWindow()
WinCompositorWidgetProxy::OnDestroyWindow()
{
mTransparentSurface = nullptr;
mMemoryDC = nullptr;
}
bool
WinCompositorWidget::PreRender(layers::LayerManagerComposite* aManager)
WinCompositorWidgetProxy::PreRender(layers::LayerManagerComposite* aManager)
{
// This can block waiting for WM_SETTEXT to finish
// Using PreRender is unnecessarily pessimistic because
@ -52,20 +46,19 @@ WinCompositorWidget::PreRender(layers::LayerManagerComposite* aManager)
}
void
WinCompositorWidget::PostRender(layers::LayerManagerComposite* aManager)
WinCompositorWidgetProxy::PostRender(layers::LayerManagerComposite* aManager)
{
mPresentLock.Leave();
}
nsIWidget*
WinCompositorWidget::RealWidget()
WinCompositorWidgetProxy::RealWidget()
{
MOZ_ASSERT(mWindow);
return mWindow;
}
LayoutDeviceIntSize
WinCompositorWidget::GetClientSize()
WinCompositorWidgetProxy::GetClientSize()
{
RECT r;
if (!::GetClientRect(mWnd, &r)) {
@ -77,7 +70,7 @@ WinCompositorWidget::GetClientSize()
}
already_AddRefed<gfx::DrawTarget>
WinCompositorWidget::StartRemoteDrawing()
WinCompositorWidgetProxy::StartRemoteDrawing()
{
MOZ_ASSERT(!mCompositeDC);
@ -113,7 +106,7 @@ WinCompositorWidget::StartRemoteDrawing()
}
void
WinCompositorWidget::EndRemoteDrawing()
WinCompositorWidgetProxy::EndRemoteDrawing()
{
MOZ_ASSERT(!mLockedBackBufferData);
@ -128,14 +121,14 @@ WinCompositorWidget::EndRemoteDrawing()
}
already_AddRefed<gfx::DrawTarget>
WinCompositorWidget::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect)
WinCompositorWidgetProxy::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect)
{
MOZ_ASSERT(!mLockedBackBufferData);
RefPtr<gfx::DrawTarget> target =
CompositorWidget::GetBackBufferDrawTarget(aScreenTarget, aRect, aClearRect);
CompositorWidgetProxy::GetBackBufferDrawTarget(aScreenTarget, aRect, aClearRect);
if (!target) {
return nullptr;
}
@ -163,49 +156,49 @@ WinCompositorWidget::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
}
already_AddRefed<gfx::SourceSurface>
WinCompositorWidget::EndBackBufferDrawing()
WinCompositorWidgetProxy::EndBackBufferDrawing()
{
if (mLockedBackBufferData) {
MOZ_ASSERT(mLastBackBuffer);
mLastBackBuffer->ReleaseBits(mLockedBackBufferData);
mLockedBackBufferData = nullptr;
}
return CompositorWidget::EndBackBufferDrawing();
return CompositorWidgetProxy::EndBackBufferDrawing();
}
already_AddRefed<CompositorVsyncDispatcher>
WinCompositorWidget::GetCompositorVsyncDispatcher()
WinCompositorWidgetProxy::GetCompositorVsyncDispatcher()
{
RefPtr<CompositorVsyncDispatcher> cvd = mWindow->GetCompositorVsyncDispatcher();
return cvd.forget();
}
uintptr_t
WinCompositorWidget::GetWidgetKey()
WinCompositorWidgetProxy::GetWidgetKey()
{
return mWidgetKey;
}
void
WinCompositorWidget::EnterPresentLock()
WinCompositorWidgetProxy::EnterPresentLock()
{
mPresentLock.Enter();
}
void
WinCompositorWidget::LeavePresentLock()
WinCompositorWidgetProxy::LeavePresentLock()
{
mPresentLock.Leave();
}
RefPtr<gfxASurface>
WinCompositorWidget::EnsureTransparentSurface()
WinCompositorWidgetProxy::EnsureTransparentSurface()
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
if (!mTransparentSurface) {
LayoutDeviceIntSize size = GetClientSize();
CreateTransparentSurface(IntSize(size.width, size.height));
CreateTransparentSurface(size.width, size.height);
}
RefPtr<gfxASurface> surface = mTransparentSurface;
@ -213,16 +206,17 @@ WinCompositorWidget::EnsureTransparentSurface()
}
void
WinCompositorWidget::CreateTransparentSurface(const gfx::IntSize& aSize)
WinCompositorWidgetProxy::CreateTransparentSurface(int32_t aWidth, int32_t aHeight)
{
MOZ_ASSERT(!mTransparentSurface && !mMemoryDC);
RefPtr<gfxWindowsSurface> surface = new gfxWindowsSurface(aSize, SurfaceFormat::A8R8G8B8_UINT32);
RefPtr<gfxWindowsSurface> surface =
new gfxWindowsSurface(IntSize(aWidth, aHeight), SurfaceFormat::A8R8G8B8_UINT32);
mTransparentSurface = surface;
mMemoryDC = surface->GetDC();
}
void
WinCompositorWidget::UpdateTransparency(nsTransparencyMode aMode)
WinCompositorWidgetProxy::UpdateTransparency(nsTransparencyMode aMode)
{
if (mTransparencyMode == aMode) {
return;
@ -238,7 +232,7 @@ WinCompositorWidget::UpdateTransparency(nsTransparencyMode aMode)
}
void
WinCompositorWidget::ClearTransparentWindow()
WinCompositorWidgetProxy::ClearTransparentWindow()
{
if (!mTransparentSurface) {
return;
@ -252,11 +246,13 @@ WinCompositorWidget::ClearTransparentWindow()
}
void
WinCompositorWidget::ResizeTransparentWindow(const gfx::IntSize& aSize)
WinCompositorWidgetProxy::ResizeTransparentWindow(int32_t aNewWidth, int32_t aNewHeight)
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
if (mTransparentSurface && mTransparentSurface->GetSize() == aSize) {
if (mTransparentSurface &&
mTransparentSurface->GetSize() == IntSize(aNewWidth, aNewHeight))
{
return;
}
@ -264,11 +260,11 @@ WinCompositorWidget::ResizeTransparentWindow(const gfx::IntSize& aSize)
mTransparentSurface = nullptr;
mMemoryDC = nullptr;
CreateTransparentSurface(aSize);
CreateTransparentSurface(aNewWidth, aNewHeight);
}
bool
WinCompositorWidget::RedrawTransparentWindow()
WinCompositorWidgetProxy::RedrawTransparentWindow()
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
@ -290,7 +286,7 @@ WinCompositorWidget::RedrawTransparentWindow()
}
HDC
WinCompositorWidget::GetWindowSurface()
WinCompositorWidgetProxy::GetWindowSurface()
{
return eTransparencyTransparent == mTransparencyMode
? mMemoryDC
@ -298,7 +294,7 @@ WinCompositorWidget::GetWindowSurface()
}
void
WinCompositorWidget::FreeWindowSurface(HDC dc)
WinCompositorWidgetProxy::FreeWindowSurface(HDC dc)
{
if (eTransparencyTransparent != mTransparencyMode)
::ReleaseDC(mWnd, dc);

63
widget/windows/WinCompositorWidget.h → widget/windows/WinCompositorWidgetProxy.h
View File

@ -3,51 +3,25 @@
* 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
#ifndef _widget_windows_WinCompositorWidget_h__
#define _widget_windows_WinCompositorWidget_h__
#include "CompositorWidget.h"
#include "gfxASurface.h"
#include "CompositorWidgetProxy.h"
#include "mozilla/gfx/CriticalSection.h"
#include "mozilla/gfx/Point.h"
#include "nsIWidget.h"
class nsWindow;
namespace mozilla {
namespace widget {
class 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;
// Update the bounds of the transparent surface.
virtual void ResizeTransparentWindow(const gfx::IntSize& aSize) = 0;
// If in-process and using software rendering, return the backing transparent
// DC.
virtual HDC GetTransparentDC() const = 0;
};
// This is the Windows-specific implementation of CompositorWidget. For
// This is the Windows-specific implementation of CompositorWidgetProxy. 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 CompositorWidgetDelegate
class WinCompositorWidgetProxy : public CompositorWidgetProxy
{
public:
WinCompositorWidget(const CompositorWidgetInitData& aInitData,
nsWindow* aWindow = nullptr);
WinCompositorWidgetProxy(nsWindow* aWindow);
bool PreRender(layers::LayerManagerComposite*) override;
void PostRender(layers::LayerManagerComposite*) override;
@ -61,24 +35,27 @@ public:
already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() override;
uintptr_t GetWidgetKey() override;
nsIWidget* RealWidget() override;
WinCompositorWidget* AsWindows() override {
WinCompositorWidgetProxy* AsWindowsProxy() override {
return this;
}
// CompositorWidgetDelegate overrides.
void EnterPresentLock() override;
void LeavePresentLock() override;
void OnDestroyWindow() override;
void UpdateTransparency(nsTransparencyMode aMode) override;
void ClearTransparentWindow() override;
void ResizeTransparentWindow(const gfx::IntSize& aSize) override;
// Callbacks for nsWindow.
void EnterPresentLock();
void LeavePresentLock();
void OnDestroyWindow();
// Transparency handling.
void UpdateTransparency(nsTransparencyMode aMode);
void ClearTransparentWindow();
bool RedrawTransparentWindow();
// Update the bounds of the transparent surface.
void ResizeTransparentWindow(int32_t aNewWidth, int32_t aNewHeight);
// Ensure that a transparent surface exists, then return it.
RefPtr<gfxASurface> EnsureTransparentSurface();
HDC GetTransparentDC() const override {
HDC GetTransparentDC() const {
return mMemoryDC;
}
HWND GetHwnd() const {
@ -89,7 +66,7 @@ private:
HDC GetWindowSurface();
void FreeWindowSurface(HDC dc);
void CreateTransparentSurface(const gfx::IntSize& aSize);
void CreateTransparentSurface(int32_t aWidth, int32_t aHeight);
private:
nsWindow* mWindow;
@ -110,4 +87,4 @@ private:
} // namespace widget
} // namespace mozilla
#endif // widget_windows_CompositorWidgetParent_h
#endif // _widget_windows_WinCompositorWidget_h__

8
widget/windows/moz.build
View File

@ -14,9 +14,7 @@ EXPORTS += [
EXPORTS.mozilla.widget += [
'AudioSession.h',
'CompositorWidgetChild.h',
'CompositorWidgetParent.h',
'WinCompositorWidget.h',
'WinCompositorWidgetProxy.h',
'WinMessages.h',
'WinModifierKeyState.h',
'WinNativeEventData.h',
@ -24,8 +22,6 @@ EXPORTS.mozilla.widget += [
UNIFIED_SOURCES += [
'AudioSession.cpp',
'CompositorWidgetChild.cpp',
'CompositorWidgetParent.cpp',
'GfxInfo.cpp',
'IEnumFE.cpp',
'IMMHandler.cpp',
@ -59,7 +55,7 @@ UNIFIED_SOURCES += [
'TaskbarTabPreview.cpp',
'TaskbarWindowPreview.cpp',
'WidgetTraceEvent.cpp',
'WinCompositorWidget.cpp',
'WinCompositorWidgetProxy.cpp',
'WindowHook.cpp',
'WinIMEHandler.cpp',
'WinTaskbar.cpp',

70
widget/windows/nsWindow.cpp
View File

@ -136,12 +136,11 @@
#include "mozilla/TextEvents.h" // For WidgetKeyboardEvent
#include "mozilla/TextEventDispatcherListener.h"
#include "mozilla/widget/WinNativeEventData.h"
#include "mozilla/widget/PlatformWidgetTypes.h"
#include "nsThemeConstants.h"
#include "nsBidiKeyboard.h"
#include "nsThemeConstants.h"
#include "gfxConfig.h"
#include "WinCompositorWidget.h"
#include "WinCompositorWidgetProxy.h"
#include "nsIGfxInfo.h"
#include "nsUXThemeConstants.h"
@ -1292,8 +1291,8 @@ NS_METHOD nsWindow::Show(bool bState)
// Clear contents to avoid ghosting of old content if we display
// this window again.
if (wasVisible && mTransparencyMode == eTransparencyTransparent) {
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->ClearTransparentWindow();
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->ClearTransparentWindow();
}
}
if (mWindowType != eWindowType_dialog) {
@ -1551,8 +1550,8 @@ NS_METHOD nsWindow::Resize(double aWidth, double aHeight, bool aRepaint)
}
if (mTransparencyMode == eTransparencyTransparent) {
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->ResizeTransparentWindow(gfx::IntSize(width, height));
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->ResizeTransparentWindow(width, height);
}
}
@ -1610,8 +1609,8 @@ NS_METHOD nsWindow::Resize(double aX, double aY, double aWidth, double aHeight,
}
if (eTransparencyTransparent == mTransparencyMode) {
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->ResizeTransparentWindow(gfx::IntSize(width, height));
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->ResizeTransparentWindow(width, height);
}
}
@ -3623,16 +3622,13 @@ nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
if (!mLayerManager) {
MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild);
MOZ_ASSERT(!mCompositorWidgetDelegate);
// Ensure we have a widget proxy even if we're not using the compositor,
// since all our transparent window handling lives there.
CompositorWidgetInitData initData(
reinterpret_cast<uintptr_t>(mWnd),
reinterpret_cast<uintptr_t>(static_cast<nsIWidget*>(this)),
mTransparencyMode);
mBasicLayersSurface = new WinCompositorWidget(initData, this);
mCompositorWidgetDelegate = mBasicLayersSurface;
// since that's where we handle transparent windows.
if (!mCompositorWidgetProxy) {
mCompositorWidgetProxy = new WinCompositorWidgetProxy(this);
}
mLayerManager = CreateBasicLayerManager();
}
@ -3693,6 +3689,18 @@ nsWindow::OnDefaultButtonLoaded(const LayoutDeviceIntRect& aButtonRect)
return NS_OK;
}
mozilla::widget::CompositorWidgetProxy*
nsWindow::NewCompositorWidgetProxy()
{
return new WinCompositorWidgetProxy(this);
}
mozilla::widget::WinCompositorWidgetProxy*
nsWindow::GetCompositorWidgetProxy()
{
return mCompositorWidgetProxy ? mCompositorWidgetProxy->AsWindowsProxy() : nullptr;
}
void
nsWindow::UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries)
{
@ -4895,16 +4903,17 @@ nsWindow::ProcessMessage(UINT msg, WPARAM& wParam, LPARAM& lParam,
//
// To do this we take mPresentLock in nsWindow::PreRender and
// if that lock is taken we wait before doing WM_SETTEXT
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->EnterPresentLock();
RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy();
if (proxy) {
proxy->EnterPresentLock();
}
DWORD style = GetWindowLong(mWnd, GWL_STYLE);
SetWindowLong(mWnd, GWL_STYLE, style & ~WS_VISIBLE);
*aRetValue = CallWindowProcW(GetPrevWindowProc(), mWnd,
msg, wParam, lParam);
SetWindowLong(mWnd, GWL_STYLE, style);
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->LeavePresentLock();
if (proxy) {
proxy->LeavePresentLock();
}
return true;
@ -6205,8 +6214,8 @@ void nsWindow::OnWindowPosChanged(WINDOWPOS* wp)
nsIntRect rect(wp->x, wp->y, newWidth, newHeight);
if (eTransparencyTransparent == mTransparencyMode) {
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->ResizeTransparentWindow(gfx::IntSize(newWidth, newHeight));
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->ResizeTransparentWindow(newWidth, newHeight);
}
}
@ -6726,10 +6735,9 @@ void nsWindow::OnDestroy()
if (mCursor == -1)
SetCursor(eCursor_standard);
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->OnDestroyWindow();
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->OnDestroyWindow();
}
mBasicLayersSurface = nullptr;
// Finalize panning feedback to possibly restore window displacement
mGesture.PanFeedbackFinalize(mWnd, true);
@ -7044,8 +7052,8 @@ void nsWindow::SetWindowTranslucencyInner(nsTransparencyMode aMode)
memset(&mGlassMargins, 0, sizeof mGlassMargins);
mTransparencyMode = aMode;
if (mCompositorWidgetDelegate) {
mCompositorWidgetDelegate->UpdateTransparency(aMode);
if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
proxy->UpdateTransparency(aMode);
}
UpdateGlass();
}
@ -7816,11 +7824,3 @@ DWORD ChildWindow::WindowStyle()
VERIFY_WINDOW_STYLE(style);
return style;
}
void
nsWindow::GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData)
{
aInitData->hWnd() = reinterpret_cast<uintptr_t>(mWnd);
aInitData->widgetKey() = reinterpret_cast<uintptr_t>(static_cast<nsIWidget*>(this));
aInitData->transparencyMode() = mTransparencyMode;
}

8
widget/windows/nsWindow.h
View File

@ -57,8 +57,8 @@ class imgIContainer;
namespace mozilla {
namespace widget {
class NativeKey;
class WinCompositorWidget;
struct MSGResult;
class WinCompositorWidgetProxy;
} // namespace widget
} // namespacw mozilla;
@ -313,7 +313,7 @@ public:
const mozilla::NativeEventData& aKeyEventData,
nsIKeyEventInPluginCallback* aCallback) override;
void GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData) override;
mozilla::widget::CompositorWidgetProxy* NewCompositorWidgetProxy() override;
protected:
virtual ~nsWindow();
@ -488,6 +488,8 @@ protected:
void ClearCachedResources();
nsIWidgetListener* GetPaintListener();
mozilla::widget::WinCompositorWidgetProxy* GetCompositorWidgetProxy();
protected:
nsCOMPtr<nsIWidget> mParent;
nsIntSize mLastSize;
@ -620,8 +622,6 @@ protected:
TimeStamp mCachedHitTestTime;
int32_t mCachedHitTestResult;
RefPtr<mozilla::widget::WinCompositorWidget> mBasicLayersSurface;
static bool sNeedsToInitMouseWheelSettings;
static void InitMouseWheelScrollData();

6
widget/windows/nsWindowGfx.cpp
View File

@ -239,7 +239,7 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t aNestingLevel)
::EndPaint(mWnd, &ps);
// We're guaranteed to have a widget proxy since we called GetLayerManager().
aDC = mCompositorWidgetDelegate->GetTransparentDC();
aDC = GetCompositorWidgetProxy()->GetTransparentDC();
}
#endif
@ -313,7 +313,7 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t aNestingLevel)
#if defined(MOZ_XUL)
// don't support transparency for non-GDI rendering, for now
if (eTransparencyTransparent == mTransparencyMode) {
targetSurface = mBasicLayersSurface->EnsureTransparentSurface();
targetSurface = GetCompositorWidgetProxy()->EnsureTransparentSurface();
}
#endif
@ -378,7 +378,7 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t aNestingLevel)
// Data from offscreen drawing surface was copied to memory bitmap of transparent
// bitmap. Now it can be read from memory bitmap to apply alpha channel and after
// that displayed on the screen.
mBasicLayersSurface->RedrawTransparentWindow();
GetCompositorWidgetProxy()->RedrawTransparentWindow();
}
#endif
}