diff --git a/gfx/ipc/CompositorSession.cpp b/gfx/ipc/CompositorSession.cpp index 6de7dd7d2f76..756dc3cf0650 100644 --- a/gfx/ipc/CompositorSession.cpp +++ b/gfx/ipc/CompositorSession.cpp @@ -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 mCompositorBridgeParent; - RefPtr mCompositorWidget; }; already_AddRefed -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 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 diff --git a/gfx/ipc/CompositorSession.h b/gfx/ipc/CompositorSession.h index e19ad1cf1e6f..1421b6585771 100644 --- a/gfx/ipc/CompositorSession.h +++ b/gfx/ipc/CompositorSession.h @@ -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 CreateInProcess( - nsIWidget* aWidget, + widget::CompositorWidgetProxy* aWidgetProxy, ClientLayerManager* aLayerManager, CSSToLayoutDeviceScale aScale, bool aUseAPZ, @@ -78,7 +66,6 @@ protected: protected: RefPtr mCompositorBridgeChild; - CompositorWidgetDelegate* mCompositorWidgetDelegate; private: DISALLOW_COPY_AND_ASSIGN(CompositorSession); diff --git a/gfx/ipc/GPUProcessManager.cpp b/gfx/ipc/GPUProcessManager.cpp index a04a325d2641..037817fc0158 100644 --- a/gfx/ipc/GPUProcessManager.cpp +++ b/gfx/ipc/GPUProcessManager.cpp @@ -150,7 +150,7 @@ GPUProcessManager::DestroyProcess() } already_AddRefed -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, diff --git a/gfx/ipc/GPUProcessManager.h b/gfx/ipc/GPUProcessManager.h index aee41cb6bae1..f740792fb57b 100644 --- a/gfx/ipc/GPUProcessManager.h +++ b/gfx/ipc/GPUProcessManager.h @@ -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 CreateTopLevelCompositor( - nsIWidget* aWidget, + widget::CompositorWidgetProxy* aProxy, layers::ClientLayerManager* aLayerManager, CSSToLayoutDeviceScale aScale, bool aUseAPZ, diff --git a/gfx/layers/Compositor.cpp b/gfx/layers/Compositor.cpp index d8690863c102..1ac48e97dd8a 100644 --- a/gfx/layers/Compositor.cpp +++ b/gfx/layers/Compositor.cpp @@ -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) diff --git a/gfx/layers/Compositor.h b/gfx/layers/Compositor.h index 31db7b2b5a41..2e8865a574af 100644 --- a/gfx/layers/Compositor.h +++ b/gfx/layers/Compositor.h @@ -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 #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 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 mTarget; gfx::IntRect mTargetBounds; - widget::CompositorWidget* mWidget; + widget::CompositorWidgetProxy* mWidget; bool mIsDestroyed; diff --git a/gfx/layers/basic/BasicCompositor.cpp b/gfx/layers/basic/BasicCompositor.cpp index 6076cf0e33a5..12ee4628df3b 100644 --- a/gfx/layers/basic/BasicCompositor.cpp +++ b/gfx/layers/basic/BasicCompositor.cpp @@ -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) { diff --git a/gfx/layers/basic/BasicCompositor.h b/gfx/layers/basic/BasicCompositor.h index 06455447a0b2..1fd30a0bc51e 100644 --- a/gfx/layers/basic/BasicCompositor.h +++ b/gfx/layers/basic/BasicCompositor.h @@ -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(); diff --git a/gfx/layers/basic/X11BasicCompositor.h b/gfx/layers/basic/X11BasicCompositor.h index 2504e3f67af2..43262697e701 100644 --- a/gfx/layers/basic/X11BasicCompositor.h +++ b/gfx/layers/basic/X11BasicCompositor.h @@ -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) {} diff --git a/gfx/layers/d3d11/CompositorD3D11.cpp b/gfx/layers/d3d11/CompositorD3D11.cpp index 018d817a6e61..eb7016cc9929 100644 --- a/gfx/layers/d3d11/CompositorD3D11.cpp +++ b/gfx/layers/d3d11/CompositorD3D11.cpp @@ -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)); diff --git a/gfx/layers/d3d11/CompositorD3D11.h b/gfx/layers/d3d11/CompositorD3D11.h index 581ed71c38b0..9a6e3a91847f 100644 --- a/gfx/layers/d3d11/CompositorD3D11.h +++ b/gfx/layers/d3d11/CompositorD3D11.h @@ -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; } diff --git a/gfx/layers/d3d9/CompositorD3D9.cpp b/gfx/layers/d3d9/CompositorD3D9.cpp index 42671ff08a74..ebb7bf3c31d0 100644 --- a/gfx/layers/d3d9/CompositorD3D9.cpp +++ b/gfx/layers/d3d9/CompositorD3D9.cpp @@ -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 diff --git a/gfx/layers/d3d9/CompositorD3D9.h b/gfx/layers/d3d9/CompositorD3D9.h index 5e3cf4d8fdca..2d241685d68c 100644 --- a/gfx/layers/d3d9/CompositorD3D9.h +++ b/gfx/layers/d3d9/CompositorD3D9.h @@ -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; } diff --git a/gfx/layers/ipc/CompositorBridgeChild.cpp b/gfx/layers/ipc/CompositorBridgeChild.cpp index 7a70c1562710..6014a674ded3 100644 --- a/gfx/layers/ipc/CompositorBridgeChild.cpp +++ b/gfx/layers/ipc/CompositorBridgeChild.cpp @@ -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 diff --git a/gfx/layers/ipc/CompositorBridgeChild.h b/gfx/layers/ipc/CompositorBridgeChild.h index 78ac98821a05..863c01bf30f3 100644 --- a/gfx/layers/ipc/CompositorBridgeChild.h +++ b/gfx/layers/ipc/CompositorBridgeChild.h @@ -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(); diff --git a/gfx/layers/ipc/CompositorBridgeParent.cpp b/gfx/layers/ipc/CompositorBridgeParent.cpp index c022bc68eede..3365e0be17ee 100644 --- a/gfx/layers/ipc/CompositorBridgeParent.cpp +++ b/gfx/layers/ipc/CompositorBridgeParent.cpp @@ -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& aBackendHin RefPtr 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(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; diff --git a/gfx/layers/ipc/CompositorBridgeParent.h b/gfx/layers/ipc/CompositorBridgeParent.h index 53b810f44cf2..c66b36ecd2b9 100644 --- a/gfx/layers/ipc/CompositorBridgeParent.h +++ b/gfx/layers/ipc/CompositorBridgeParent.h @@ -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 mLayerManager; RefPtr mCompositor; RefPtr mCompositionManager; - widget::CompositorWidget* mWidget; + widget::CompositorWidgetProxy* mWidgetProxy; TimeStamp mTestTime; bool mIsTesting; diff --git a/gfx/layers/ipc/PCompositorBridge.ipdl b/gfx/layers/ipc/PCompositorBridge.ipdl index 51676691e61b..113fe283c57b 100644 --- a/gfx/layers/ipc/PCompositorBridge.ipdl +++ b/gfx/layers/ipc/PCompositorBridge.ipdl @@ -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. */ diff --git a/gfx/layers/opengl/CompositorOGL.cpp b/gfx/layers/opengl/CompositorOGL.cpp index 1371ba9696b4..f6f8ecc511e5 100644 --- a/gfx/layers/opengl/CompositorOGL.cpp +++ b/gfx/layers/opengl/CompositorOGL.cpp @@ -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(); diff --git a/gfx/layers/opengl/CompositorOGL.h b/gfx/layers/opengl/CompositorOGL.h index ebb8c06f92bd..7f3de137ce92 100644 --- a/gfx/layers/opengl/CompositorOGL.h +++ b/gfx/layers/opengl/CompositorOGL.h @@ -193,7 +193,7 @@ class CompositorOGL final : public Compositor std::map mPrograms; public: explicit CompositorOGL(CompositorBridgeParent* aParent, - widget::CompositorWidget* aWidget, + widget::CompositorWidgetProxy* aWidget, int aSurfaceWidth = -1, int aSurfaceHeight = -1, bool aUseExternalSurfaceSize = false); diff --git a/gfx/tests/gtest/TestCompositor.cpp b/gfx/tests/gtest/TestCompositor.cpp index 2a10b2b94b3a..97a143095770 100644 --- a/gfx/tests/gtest/TestCompositor.cpp +++ b/gfx/tests/gtest/TestCompositor.cpp @@ -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 mWidget; RefPtr mCompositor; - RefPtr mCompositorWidget; + RefPtr mCompositorWidgetProxy; RefPtr 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 CreateTestCompositor(LayersBackend backend, widget::CompositorWidget* widget) +static already_AddRefed CreateTestCompositor(LayersBackend backend, widget::CompositorWidgetProxy* widget) { gfxPrefs::GetSingleton(); @@ -158,7 +157,7 @@ static std::vector GetLayerManagers(std::vector auto backend = aBackends[i]; RefPtr widget = new MockWidget(); - RefPtr proxy = new widget::InProcessCompositorWidget(widget); + RefPtr proxy = widget->NewCompositorWidgetProxy(); RefPtr compositor = CreateTestCompositor(backend, proxy); RefPtr layerManager = new LayerManagerComposite(compositor); diff --git a/widget/CompositorWidget.cpp b/widget/CompositorWidget.cpp deleted file mode 100644 index f5b86f1152ab..000000000000 --- a/widget/CompositorWidget.cpp +++ /dev/null @@ -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 -CompositorWidget::StartRemoteDrawing() -{ - return nullptr; -} - -void -CompositorWidget::CleanupRemoteDrawing() -{ - mLastBackBuffer = nullptr; -} - -already_AddRefed -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 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 -CompositorWidget::EndBackBufferDrawing() -{ - RefPtr surface = mLastBackBuffer ? mLastBackBuffer->Snapshot() : nullptr; - return surface.forget(); -} - -uint32_t -CompositorWidget::GetGLFrameBufferFormat() -{ - return LOCAL_GL_RGBA; -} - -} // namespace widget -} // namespace mozilla diff --git a/widget/CompositorWidgetProxy.cpp b/widget/CompositorWidgetProxy.cpp new file mode 100644 index 000000000000..d207be24a9db --- /dev/null +++ b/widget/CompositorWidgetProxy.cpp @@ -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 +CompositorWidgetProxy::StartRemoteDrawing() +{ + return nullptr; +} + +void +CompositorWidgetProxy::CleanupRemoteDrawing() +{ + mLastBackBuffer = nullptr; +} + +already_AddRefed +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 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 +CompositorWidgetProxy::EndBackBufferDrawing() +{ + RefPtr 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 +CompositorWidgetProxyWrapper::StartRemoteDrawing() +{ + return mWidget->StartRemoteDrawing(); +} + +already_AddRefed +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(mWidget); +} + +nsIWidget* +CompositorWidgetProxyWrapper::RealWidget() +{ + return mWidget; +} + +already_AddRefed +CompositorWidgetProxyWrapper::GetCompositorVsyncDispatcher() +{ + RefPtr cvd = mWidget->GetCompositorVsyncDispatcher(); + return cvd.forget(); +} + +} // namespace widget +} // namespace mozilla diff --git a/widget/CompositorWidget.h b/widget/CompositorWidgetProxy.h similarity index 73% rename from widget/CompositorWidget.h rename to widget/CompositorWidgetProxy.h index 64e78e7ffc0d..8d702a09fd40 100644 --- a/widget/CompositorWidget.h +++ b/widget/CompositorWidgetProxy.h @@ -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 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 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 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 StartRemoteDrawing() override; + virtual already_AddRefed + 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 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 diff --git a/widget/InProcessCompositorWidget.cpp b/widget/InProcessCompositorWidget.cpp deleted file mode 100644 index 9411fd3fa7f9..000000000000 --- a/widget/InProcessCompositorWidget.cpp +++ /dev/null @@ -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::CreateLocal(const CompositorWidgetInitData& aInitData, nsIWidget* aWidget) -{ - MOZ_ASSERT(aWidget); - return new InProcessCompositorWidget(static_cast(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 -InProcessCompositorWidget::StartRemoteDrawing() -{ - return mWidget->StartRemoteDrawing(); -} - -already_AddRefed -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(mWidget); -} - -nsIWidget* -InProcessCompositorWidget::RealWidget() -{ - return mWidget; -} - -already_AddRefed -InProcessCompositorWidget::GetCompositorVsyncDispatcher() -{ - RefPtr cvd = mWidget->GetCompositorVsyncDispatcher(); - return cvd.forget(); -} - -} // namespace widget -} // namespace mozilla - diff --git a/widget/InProcessCompositorWidget.h b/widget/InProcessCompositorWidget.h deleted file mode 100644 index e41f781bb063..000000000000 --- a/widget/InProcessCompositorWidget.h +++ /dev/null @@ -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 StartRemoteDrawing() override; - virtual already_AddRefed - 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 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 diff --git a/widget/PCompositorWidget.ipdl b/widget/PCompositorWidget.ipdl deleted file mode 100644 index 2789f6d25b42..000000000000 --- a/widget/PCompositorWidget.ipdl +++ /dev/null @@ -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 diff --git a/widget/PlatformWidgetTypes.ipdlh b/widget/PlatformWidgetTypes.ipdlh deleted file mode 100644 index 26933f8ded53..000000000000 --- a/widget/PlatformWidgetTypes.ipdlh +++ /dev/null @@ -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 diff --git a/widget/PuppetWidget.h b/widget/PuppetWidget.h index c6a2600f9405..9ecefa76b206 100644 --- a/widget/PuppetWidget.h +++ b/widget/PuppetWidget.h @@ -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(); diff --git a/widget/cocoa/nsCocoaWindow.h b/widget/cocoa/nsCocoaWindow.h index fab0c4f07cdf..1edcda1209c0 100644 --- a/widget/cocoa/nsCocoaWindow.h +++ b/widget/cocoa/nsCocoaWindow.h @@ -354,6 +354,10 @@ public: NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent) override; + CompositorWidgetProxy* NewCompositorWidgetProxy() override { + return nullptr; + } + protected: virtual ~nsCocoaWindow(); diff --git a/widget/moz.build b/widget/moz.build index 570606eb74dc..b7d72c416a1f 100644 --- a/widget/moz.build +++ b/widget/moz.build @@ -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 diff --git a/widget/nsBaseWidget.cpp b/widget/nsBaseWidget.cpp index 9e646ece0830..254753ce1672 100644 --- a/widget/nsBaseWidget.cpp +++ b/widget/nsBaseWidget.cpp @@ -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 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 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 diff --git a/widget/nsBaseWidget.h b/widget/nsBaseWidget.h index 6d5ea598ba28..113d0bcb4c0a 100644 --- a/widget/nsBaseWidget.h +++ b/widget/nsBaseWidget.h @@ -21,6 +21,7 @@ #include "nsIWidgetListener.h" #include "nsPIDOMWindow.h" #include "nsWeakReference.h" +#include "CompositorWidgetProxy.h" #include 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 mCompositorWidgetProxy; bool mUpdateCursor; bool mUseAttachedEvents; diff --git a/widget/nsIWidget.h b/widget/nsIWidget.h index 9f953fedab44..917d27b92a2c 100644 --- a/widget/nsIWidget.h +++ b/widget/nsIWidget.h @@ -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 { diff --git a/widget/windows/CompositorWidgetChild.cpp b/widget/windows/CompositorWidgetChild.cpp deleted file mode 100644 index 2af2eadfa21f..000000000000 --- a/widget/windows/CompositorWidgetChild.cpp +++ /dev/null @@ -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(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 diff --git a/widget/windows/CompositorWidgetChild.h b/widget/windows/CompositorWidgetChild.h deleted file mode 100644 index 6dd954c3c39f..000000000000 --- a/widget/windows/CompositorWidgetChild.h +++ /dev/null @@ -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 diff --git a/widget/windows/CompositorWidgetParent.cpp b/widget/windows/CompositorWidgetParent.cpp deleted file mode 100644 index c5ddb6513e4e..000000000000 --- a/widget/windows/CompositorWidgetParent.cpp +++ /dev/null @@ -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(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 diff --git a/widget/windows/CompositorWidgetParent.h b/widget/windows/CompositorWidgetParent.h deleted file mode 100644 index 35e67c533e4c..000000000000 --- a/widget/windows/CompositorWidgetParent.h +++ /dev/null @@ -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__ diff --git a/widget/windows/PCompositorWidget.ipdl b/widget/windows/PCompositorWidget.ipdl deleted file mode 100644 index 7da1b5e9b14f..000000000000 --- a/widget/windows/PCompositorWidget.ipdl +++ /dev/null @@ -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 diff --git a/widget/windows/PlatformWidgetTypes.ipdlh b/widget/windows/PlatformWidgetTypes.ipdlh deleted file mode 100644 index aad9cf395969..000000000000 --- a/widget/windows/PlatformWidgetTypes.ipdlh +++ /dev/null @@ -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 diff --git a/widget/windows/WinCompositorWidget.cpp b/widget/windows/WinCompositorWidgetProxy.cpp similarity index 70% rename from widget/windows/WinCompositorWidget.cpp rename to widget/windows/WinCompositorWidgetProxy.cpp index b494fad9deac..44da70ce8602 100644 --- a/widget/windows/WinCompositorWidget.cpp +++ b/widget/windows/WinCompositorWidgetProxy.cpp @@ -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::CreateLocal(const CompositorWidgetInitData& aInitData, nsIWidget* aWidget) -{ - return new WinCompositorWidget(aInitData, static_cast(aWidget)); -} - -WinCompositorWidget::WinCompositorWidget(const CompositorWidgetInitData& aInitData, - nsWindow* aWindow) +WinCompositorWidgetProxy::WinCompositorWidgetProxy(nsWindow* aWindow) : mWindow(aWindow), - mWidgetKey(aInitData.widgetKey()), - mWnd(reinterpret_cast(aInitData.hWnd())), - mTransparencyMode(static_cast(aInitData.transparencyMode())), + mWidgetKey(reinterpret_cast(aWindow)), + mWnd(reinterpret_cast(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 -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 -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 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 -WinCompositorWidget::EndBackBufferDrawing() +WinCompositorWidgetProxy::EndBackBufferDrawing() { if (mLockedBackBufferData) { MOZ_ASSERT(mLastBackBuffer); mLastBackBuffer->ReleaseBits(mLockedBackBufferData); mLockedBackBufferData = nullptr; } - return CompositorWidget::EndBackBufferDrawing(); + return CompositorWidgetProxy::EndBackBufferDrawing(); } already_AddRefed -WinCompositorWidget::GetCompositorVsyncDispatcher() +WinCompositorWidgetProxy::GetCompositorVsyncDispatcher() { RefPtr 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 -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 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 surface = new gfxWindowsSurface(aSize, SurfaceFormat::A8R8G8B8_UINT32); + RefPtr 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); diff --git a/widget/windows/WinCompositorWidget.h b/widget/windows/WinCompositorWidgetProxy.h similarity index 61% rename from widget/windows/WinCompositorWidget.h rename to widget/windows/WinCompositorWidgetProxy.h index aca0bed3fbdd..3319306716ac 100644 --- a/widget/windows/WinCompositorWidget.h +++ b/widget/windows/WinCompositorWidgetProxy.h @@ -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 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 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__ diff --git a/widget/windows/moz.build b/widget/windows/moz.build index d967b758e3ca..1bb9f6ab5c62 100644 --- a/widget/windows/moz.build +++ b/widget/windows/moz.build @@ -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', diff --git a/widget/windows/nsWindow.cpp b/widget/windows/nsWindow.cpp index 3775f6303467..b3ceff644ff8 100644 --- a/widget/windows/nsWindow.cpp +++ b/widget/windows/nsWindow.cpp @@ -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 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 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 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(mWnd), - reinterpret_cast(static_cast(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& 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 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 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 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 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(mWnd); - aInitData->widgetKey() = reinterpret_cast(static_cast(this)); - aInitData->transparencyMode() = mTransparencyMode; -} diff --git a/widget/windows/nsWindow.h b/widget/windows/nsWindow.h index 207cbf679dd9..386ba048b8b6 100644 --- a/widget/windows/nsWindow.h +++ b/widget/windows/nsWindow.h @@ -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 mParent; nsIntSize mLastSize; @@ -620,8 +622,6 @@ protected: TimeStamp mCachedHitTestTime; int32_t mCachedHitTestResult; - RefPtr mBasicLayersSurface; - static bool sNeedsToInitMouseWheelSettings; static void InitMouseWheelScrollData(); diff --git a/widget/windows/nsWindowGfx.cpp b/widget/windows/nsWindowGfx.cpp index 1d239bcc79c1..8bed4fe2a3ae 100644 --- a/widget/windows/nsWindowGfx.cpp +++ b/widget/windows/nsWindowGfx.cpp @@ -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 }