--- a/gfx/ipc/CompositorSession.cpp
+++ b/gfx/ipc/CompositorSession.cpp
@@ -10,17 +10,17 @@
namespace mozilla {
namespace layers {
class InProcessCompositorSession final : public CompositorSession
{
public:
InProcessCompositorSession(
- widget::CompositorWidgetProxy* aWidgetProxy,
+ widget::CompositorWidget* aWidget,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
CompositorBridgeParent* GetInProcessBridge() const override;
void SetContentController(GeckoContentController* aController) override;
@@ -28,25 +28,25 @@ public:
already_AddRefed<APZCTreeManager> GetAPZCTreeManager() const override;
void Shutdown() override;
private:
RefPtr<CompositorBridgeParent> mCompositorBridgeParent;
};
already_AddRefed<CompositorSession>
-CompositorSession::CreateInProcess(widget::CompositorWidgetProxy* aWidgetProxy,
+CompositorSession::CreateInProcess(widget::CompositorWidget* aWidget,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
{
RefPtr<InProcessCompositorSession> session = new InProcessCompositorSession(
- aWidgetProxy,
+ aWidget,
aLayerManager,
aScale,
aUseAPZ,
aUseExternalSurfaceSize,
aSurfaceSize);
return session.forget();
}
@@ -59,25 +59,25 @@ CompositorSession::~CompositorSession()
}
CompositorBridgeChild*
CompositorSession::GetCompositorBridgeChild()
{
return mCompositorBridgeChild;
}
-InProcessCompositorSession::InProcessCompositorSession(widget::CompositorWidgetProxy* aWidgetProxy,
+InProcessCompositorSession::InProcessCompositorSession(widget::CompositorWidget* aWidget,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
{
mCompositorBridgeParent = new CompositorBridgeParent(
- aWidgetProxy,
+ aWidget,
aScale,
aUseAPZ,
aUseExternalSurfaceSize,
aSurfaceSize);
mCompositorBridgeChild = new CompositorBridgeChild(aLayerManager);
mCompositorBridgeChild->OpenSameProcess(mCompositorBridgeParent);
mCompositorBridgeParent->SetOtherProcessId(base::GetCurrentProcId());
}
--- a/gfx/ipc/CompositorSession.h
+++ b/gfx/ipc/CompositorSession.h
@@ -8,17 +8,17 @@
#include "base/basictypes.h"
#include "Units.h"
#include "nsISupportsImpl.h"
#include "mozilla/gfx/Point.h"
namespace mozilla {
namespace widget {
-class CompositorWidgetProxy;
+class CompositorWidget;
} // namespace widget
namespace gfx {
class GPUProcessManager;
} // namespace gfx
namespace layers {
class GeckoContentController;
class APZCTreeManager;
@@ -52,17 +52,17 @@ public:
// Return the child end of the compositor IPC bridge.
CompositorBridgeChild* GetCompositorBridgeChild();
protected:
CompositorSession();
virtual ~CompositorSession();
static already_AddRefed<CompositorSession> CreateInProcess(
- widget::CompositorWidgetProxy* aWidgetProxy,
+ widget::CompositorWidget* aWidget,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
protected:
RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
--- a/gfx/ipc/GPUProcessManager.cpp
+++ b/gfx/ipc/GPUProcessManager.cpp
@@ -145,25 +145,25 @@ GPUProcessManager::DestroyProcess()
}
mProcess->Shutdown();
mProcess = nullptr;
mGPUChild = nullptr;
}
already_AddRefed<CompositorSession>
-GPUProcessManager::CreateTopLevelCompositor(widget::CompositorWidgetProxy* aProxy,
+GPUProcessManager::CreateTopLevelCompositor(widget::CompositorWidget* aWidget,
ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
{
return CompositorSession::CreateInProcess(
- aProxy,
+ aWidget,
aLayerManager,
aScale,
aUseAPZ,
aUseExternalSurfaceSize,
aSurfaceSize);
}
PCompositorBridgeParent*
--- a/gfx/ipc/GPUProcessManager.h
+++ b/gfx/ipc/GPUProcessManager.h
@@ -19,17 +19,17 @@ namespace mozilla {
namespace layers {
class APZCTreeManager;
class CompositorSession;
class ClientLayerManager;
class CompositorUpdateObserver;
class PCompositorBridgeParent;
} // namespace layers
namespace widget {
-class CompositorWidgetProxy;
+class CompositorWidget;
} // namespace widget
namespace dom {
class ContentParent;
class TabParent;
} // namespace dom
namespace ipc {
class GeckoChildProcessHost;
} // namespace ipc
@@ -56,17 +56,17 @@ public:
void EnableGPUProcess();
// Ensure that GPU-bound methods can be used. If no GPU process is being
// used, or one is launched and ready, this function returns immediately.
// Otherwise it blocks until the GPU process has finished launching.
void EnsureGPUReady();
already_AddRefed<layers::CompositorSession> CreateTopLevelCompositor(
- widget::CompositorWidgetProxy* aProxy,
+ widget::CompositorWidget* aWidget,
layers::ClientLayerManager* aLayerManager,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
layers::PCompositorBridgeParent* CreateTabCompositorBridge(
ipc::Transport* aTransport,
--- a/gfx/layers/Compositor.cpp
+++ b/gfx/layers/Compositor.cpp
@@ -20,17 +20,17 @@
#include "nsWindow.h"
#include "nsScreenManagerGonk.h"
#endif
namespace mozilla {
namespace layers {
-Compositor::Compositor(widget::CompositorWidgetProxy* aWidget,
+Compositor::Compositor(widget::CompositorWidget* aWidget,
CompositorBridgeParent* aParent)
: mCompositorID(0)
, mDiagnosticTypes(DiagnosticTypes::NO_DIAGNOSTIC)
, mParent(aParent)
, mPixelsPerFrame(0)
, mPixelsFilled(0)
, mScreenRotation(ROTATION_0)
, mWidget(aWidget)
--- a/gfx/layers/Compositor.h
+++ b/gfx/layers/Compositor.h
@@ -12,21 +12,21 @@
#include "mozilla/gfx/2D.h" // for DrawTarget
#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4
#include "mozilla/gfx/Point.h" // for IntSize, Point
#include "mozilla/gfx/Rect.h" // for Rect, IntRect
#include "mozilla/gfx/Types.h" // for Float
#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
* they are flattened into the final image that is brought to the screen.
* See Layers.h for more informations about layers and why we use retained
* structures.
* Most of the documentation for layers is directly in the source code in the
* form of doc comments. An overview can also be found in the the wiki:
@@ -187,17 +187,17 @@ enum SurfaceInitMode
class Compositor
{
protected:
virtual ~Compositor();
public:
NS_INLINE_DECL_REFCOUNTING(Compositor)
- explicit Compositor(widget::CompositorWidgetProxy* aWidget,
+ explicit Compositor(widget::CompositorWidget* aWidget,
CompositorBridgeParent* aParent = nullptr);
virtual already_AddRefed<DataTextureSource> CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) = 0;
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSourceAround(gfx::DataSourceSurface* aSurface) { return nullptr; }
virtual bool Initialize() = 0;
@@ -469,17 +469,17 @@ public:
/**
* Call before rendering begins to ensure the compositor is ready to
* composite. Returns false if rendering should be aborted.
*/
virtual bool Ready() { return true; }
virtual void ForcePresent() { }
- widget::CompositorWidgetProxy* GetWidget() const { return mWidget; }
+ widget::CompositorWidget* GetWidget() const { return mWidget; }
virtual bool HasImageHostOverlays() { return false; }
virtual void AddImageHostOverlay(ImageHostOverlay* aOverlay) {}
virtual void RemoveImageHostOverlay(ImageHostOverlay* aOverlay) {}
/**
@@ -613,17 +613,17 @@ protected:
size_t mPixelsPerFrame;
size_t mPixelsFilled;
ScreenRotation mScreenRotation;
RefPtr<gfx::DrawTarget> mTarget;
gfx::IntRect mTargetBounds;
- widget::CompositorWidgetProxy* mWidget;
+ widget::CompositorWidget* mWidget;
bool mIsDestroyed;
#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
FenceHandle mReleaseFenceHandle;
#endif
private:
--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -75,17 +75,17 @@ public:
SetUpdateSerial(0);
}
public:
RefPtr<gfx::DataSourceSurface> mSurface;
bool mWrappingExistingData;
};
-BasicCompositor::BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
+BasicCompositor::BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
: Compositor(aWidget, aParent)
, mDidExternalComposition(false)
{
MOZ_COUNT_CTOR(BasicCompositor);
mMaxTextureSize =
Factory::GetMaxSurfaceSize(gfxPlatform::GetPlatform()->GetContentBackendFor(LayersBackend::LAYERS_BASIC));
}
--- a/gfx/layers/basic/BasicCompositor.h
+++ b/gfx/layers/basic/BasicCompositor.h
@@ -36,17 +36,17 @@ public:
RefPtr<gfx::DrawTarget> mDrawTarget;
gfx::IntSize mSize;
};
class BasicCompositor : public Compositor
{
public:
- explicit BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy *aWidget);
+ explicit BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
protected:
virtual ~BasicCompositor();
public:
virtual BasicCompositor* AsBasicCompositor() override { return this; }
--- a/gfx/layers/basic/X11BasicCompositor.h
+++ b/gfx/layers/basic/X11BasicCompositor.h
@@ -41,17 +41,17 @@ public:
private:
// We are going to buffer layer content on this xlib draw target
RefPtr<mozilla::gfx::DrawTarget> mBufferDrawTarget;
};
class X11BasicCompositor : public BasicCompositor
{
public:
- explicit X11BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
+ explicit X11BasicCompositor(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
: BasicCompositor(aParent, aWidget)
{}
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) override;
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSourceAround(gfx::DataSourceSurface* aSurface) override { return nullptr; }
--- a/gfx/layers/d3d11/CompositorD3D11.cpp
+++ b/gfx/layers/d3d11/CompositorD3D11.cpp
@@ -17,17 +17,17 @@
#include "mozilla/layers/Effects.h"
#include "nsWindowsHelpers.h"
#include "gfxPrefs.h"
#include "gfxConfig.h"
#include "gfxCrashReporterUtils.h"
#include "gfxVR.h"
#include "mozilla/gfx/StackArray.h"
#include "mozilla/Services.h"
-#include "mozilla/widget/WinCompositorWidgetProxy.h"
+#include "mozilla/widget/WinCompositorWidget.h"
#include "mozilla/EnumeratedArray.h"
#include "mozilla/Telemetry.h"
#include "BlendShaderConstants.h"
#include <dxgi1_2.h>
namespace mozilla {
@@ -155,17 +155,17 @@ private:
return true;
}
// Only used during initialization.
RefPtr<ID3D11Device> mDevice;
bool mInitOkay;
};
-CompositorD3D11::CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
+CompositorD3D11::CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
: Compositor(aWidget, aParent)
, mAttachments(nullptr)
, mHwnd(nullptr)
, mDisableSequenceForNextFrame(false)
, mVerifyBuffersFailed(false)
{
}
@@ -211,17 +211,17 @@ CompositorD3D11::Initialize()
if (!mContext) {
gfxCriticalNote << "[D3D11] failed to get immediate context";
return false;
}
mFeatureLevel = mDevice->GetFeatureLevel();
- mHwnd = mWidget->AsWindowsProxy()->GetHwnd();
+ mHwnd = mWidget->AsWindows()->GetHwnd();
memset(&mVSConstants, 0, sizeof(VertexShaderConstants));
int referenceCount = 0;
UINT size = sizeof(referenceCount);
// If this isn't there yet it'll fail, count will remain 0, which is correct.
mDevice->GetPrivateData(sLayerManagerCount, &size, &referenceCount);
referenceCount++;
--- a/gfx/layers/d3d11/CompositorD3D11.h
+++ b/gfx/layers/d3d11/CompositorD3D11.h
@@ -37,17 +37,17 @@ struct PixelShaderConstants
int blendConfig[4];
};
struct DeviceAttachmentsD3D11;
class CompositorD3D11 : public Compositor
{
public:
- CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget);
+ CompositorD3D11(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
~CompositorD3D11();
virtual CompositorD3D11* AsCompositorD3D11() override { return this; }
virtual bool Initialize() override;
virtual TextureFactoryIdentifier
GetTextureFactoryIdentifier() override;
--- a/gfx/layers/d3d9/CompositorD3D9.cpp
+++ b/gfx/layers/d3d9/CompositorD3D9.cpp
@@ -12,24 +12,24 @@
#include "mozilla/layers/Effects.h"
#include "nsWindowsHelpers.h"
#include "Nv3DVUtils.h"
#include "gfxFailure.h"
#include "mozilla/layers/LayerManagerComposite.h"
#include "gfxPrefs.h"
#include "gfxCrashReporterUtils.h"
#include "mozilla/layers/CompositorBridgeParent.h"
-#include "mozilla/widget/WinCompositorWidgetProxy.h"
+#include "mozilla/widget/WinCompositorWidget.h"
namespace mozilla {
namespace layers {
using namespace mozilla::gfx;
-CompositorD3D9::CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget)
+CompositorD3D9::CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget)
: Compositor(aWidget, aParent)
, mDeviceResetCount(0)
, mFailedResetAttempts(0)
{
}
CompositorD3D9::~CompositorD3D9()
{
@@ -42,17 +42,17 @@ CompositorD3D9::Initialize()
{
ScopedGfxFeatureReporter reporter("D3D9 Layers");
mDeviceManager = gfxWindowsPlatform::GetPlatform()->GetD3D9DeviceManager();
if (!mDeviceManager) {
return false;
}
- mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindowsProxy()->GetHwnd());
+ mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindows()->GetHwnd());
if (!mSwapChain) {
return false;
}
if (!mWidget->InitCompositor(this)) {
return false;
}
@@ -585,17 +585,17 @@ CompositorD3D9::SetMask(const EffectChai
*/
bool
CompositorD3D9::EnsureSwapChain()
{
MOZ_ASSERT(mDeviceManager, "Don't call EnsureSwapChain without a device manager");
if (!mSwapChain) {
- mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindowsProxy()->GetHwnd());
+ mSwapChain = mDeviceManager->CreateSwapChain(mWidget->AsWindows()->GetHwnd());
// We could not create a swap chain, return false
if (!mSwapChain) {
// Check the state of the device too
DeviceManagerState state = mDeviceManager->VerifyReadyForRendering();
if (state == DeviceMustRecreate) {
mDeviceManager = nullptr;
}
mParent->InvalidateRemoteLayers();
--- a/gfx/layers/d3d9/CompositorD3D9.h
+++ b/gfx/layers/d3d9/CompositorD3D9.h
@@ -16,17 +16,17 @@
class nsWidget;
namespace mozilla {
namespace layers {
class CompositorD3D9 : public Compositor
{
public:
- CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidgetProxy* aWidget);
+ CompositorD3D9(CompositorBridgeParent* aParent, widget::CompositorWidget* aWidget);
~CompositorD3D9();
virtual CompositorD3D9* AsCompositorD3D9() override { return this; }
virtual bool Initialize() override;
virtual TextureFactoryIdentifier
GetTextureFactoryIdentifier() override;
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -228,23 +228,23 @@ CompositorVsyncScheduler::Observer::Noti
void
CompositorVsyncScheduler::Observer::Destroy()
{
MutexAutoLock lock(mMutex);
mOwner = nullptr;
}
CompositorVsyncScheduler::CompositorVsyncScheduler(CompositorBridgeParent* aCompositorBridgeParent,
- widget::CompositorWidgetProxy* aWidgetProxy)
+ widget::CompositorWidget* aWidget)
: mCompositorBridgeParent(aCompositorBridgeParent)
, mLastCompose(TimeStamp::Now())
, mIsObservingVsync(false)
, mNeedsComposite(0)
, mVsyncNotificationsSkipped(0)
- , mCompositorVsyncDispatcher(aWidgetProxy->GetCompositorVsyncDispatcher())
+ , mCompositorVsyncDispatcher(aWidget->GetCompositorVsyncDispatcher())
, mCurrentCompositeTaskMonitor("CurrentCompositeTaskMonitor")
, mCurrentCompositeTask(nullptr)
, mSetNeedsCompositeMonitor("SetNeedsCompositeMonitor")
, mSetNeedsCompositeTask(nullptr)
#ifdef MOZ_WIDGET_GONK
#if ANDROID_VERSION >= 19
, mDisplayEnabled(false)
, mSetDisplayMonitor("SetDisplayMonitor")
@@ -577,23 +577,23 @@ CompositorVsyncScheduler::ComposeToTarge
}
static inline MessageLoop*
CompositorLoop()
{
return CompositorThreadHolder::Loop();
}
-CompositorBridgeParent::CompositorBridgeParent(widget::CompositorWidgetProxy* aWidget,
+CompositorBridgeParent::CompositorBridgeParent(widget::CompositorWidget* aWidget,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
: CompositorBridgeParentIPCAllocator("CompositorBridgeParent")
- , mWidgetProxy(aWidget)
+ , mWidget(aWidget)
, mIsTesting(false)
, mPendingTransaction(0)
, mPaused(false)
, mUseExternalSurfaceSize(aUseExternalSurfaceSize)
, mEGLSurfaceSize(aSurfaceSize)
, mPauseCompositionMonitor("PauseCompositionMonitor")
, mResumeCompositionMonitor("ResumeCompositionMonitor")
, mResetCompositorMonitor("ResetCompositorMonitor")
@@ -694,17 +694,17 @@ CompositorBridgeParent::StopAndClearReso
if (mCompositor) {
mCompositor->DetachWidget();
mCompositor->Destroy();
mCompositor = nullptr;
}
// After this point, it is no longer legal to access the widget.
- mWidgetProxy = nullptr;
+ mWidget = nullptr;
}
bool
CompositorBridgeParent::RecvWillClose()
{
StopAndClearResources();
return true;
}
@@ -1144,17 +1144,17 @@ CompositorBridgeParent::CompositeToTarge
&hasRemoteContent,
&updatePluginsFlag);
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
// We do not support plugins in local content. When switching tabs
// to local pages, hide every plugin associated with the window.
if (!hasRemoteContent && BrowserTabsRemoteAutostart() &&
mCachedPluginData.Length()) {
- Unused << SendHideAllPlugins(GetWidgetProxy()->GetWidgetKey());
+ Unused << SendHideAllPlugins(GetWidget()->GetWidgetKey());
mCachedPluginData.Clear();
}
#endif
if (aTarget) {
mLayerManager->BeginTransactionWithDrawTarget(aTarget, *aRect);
} else {
mLayerManager->BeginTransaction();
@@ -1490,34 +1490,34 @@ CompositorBridgeParent::InitializeLayerM
RefPtr<Compositor>
CompositorBridgeParent::NewCompositor(const nsTArray<LayersBackend>& aBackendHints)
{
for (size_t i = 0; i < aBackendHints.Length(); ++i) {
RefPtr<Compositor> compositor;
if (aBackendHints[i] == LayersBackend::LAYERS_OPENGL) {
compositor = new CompositorOGL(this,
- mWidgetProxy,
+ mWidget,
mEGLSurfaceSize.width,
mEGLSurfaceSize.height,
mUseExternalSurfaceSize);
} else if (aBackendHints[i] == LayersBackend::LAYERS_BASIC) {
#ifdef MOZ_WIDGET_GTK
if (gfxPlatformGtk::GetPlatform()->UseXRender()) {
- compositor = new X11BasicCompositor(this, mWidgetProxy);
+ compositor = new X11BasicCompositor(this, mWidget);
} else
#endif
{
- compositor = new BasicCompositor(this, mWidgetProxy);
+ compositor = new BasicCompositor(this, mWidget);
}
#ifdef XP_WIN
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D11) {
- compositor = new CompositorD3D11(this, mWidgetProxy);
+ compositor = new CompositorD3D11(this, mWidget);
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D9) {
- compositor = new CompositorD3D9(this, mWidgetProxy);
+ compositor = new CompositorD3D9(this, mWidget);
#endif
}
if (compositor && compositor->Initialize()) {
compositor->SetCompositorID(mCompositorID);
return compositor;
}
}
@@ -2460,17 +2460,17 @@ CompositorBridgeParent::UpdatePluginWind
if (!lts.mPluginData.Length()) {
// Don't hide plugins if the previous remote layer tree didn't contain any.
if (!mCachedPluginData.Length()) {
PLUGINS_LOG("[%" PRIu64 "] nothing to hide", aId);
return false;
}
- uintptr_t parentWidget = GetWidgetProxy()->GetWidgetKey();
+ uintptr_t parentWidget = GetWidget()->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
// to do here is hide the plugins for the old tree, so don't waste time
// calculating clipping.
mPluginsLayerOffset = nsIntPoint(0,0);
mPluginsLayerVisibleRegion.SetEmpty();
Unused << lts.mParent->SendHideAllPlugins(parentWidget);
@@ -2545,17 +2545,17 @@ CompositorBridgeParent::HideAllPluginWin
{
MOZ_ASSERT(!NS_IsMainThread());
// No plugins in the cache implies no plugins to manage
// in this content.
if (!mCachedPluginData.Length() || mDeferPluginWindows) {
return;
}
- uintptr_t parentWidget = GetWidgetProxy()->GetWidgetKey();
+ uintptr_t parentWidget = GetWidget()->GetWidgetKey();
mDeferPluginWindows = true;
mPluginWindowsHidden = true;
Unused << SendHideAllPlugins(parentWidget);
ScheduleComposition();
}
#endif // #if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -28,20 +28,20 @@
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/SharedMemory.h"
#include "mozilla/layers/GeckoContentController.h"
#include "mozilla/layers/ISurfaceAllocator.h" // for ShmemAllocator
#include "mozilla/layers/LayersMessages.h" // for TargetConfig
#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;
namespace mozilla {
class CancelableRunnable;
@@ -85,17 +85,17 @@ private:
* Turns vsync notifications into scheduled composites.
**/
class CompositorVsyncScheduler
{
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositorVsyncScheduler)
public:
explicit CompositorVsyncScheduler(CompositorBridgeParent* aCompositorBridgeParent,
- widget::CompositorWidgetProxy* aWidgetProxy);
+ widget::CompositorWidget* aWidget);
#ifdef MOZ_WIDGET_GONK
// emulator-ics never trigger the display on/off, so compositor will always
// skip composition request at that device. Only check the display status
// with kk device and upon.
#if ANDROID_VERSION >= 19
// SetDisplay() and CancelSetDisplayTask() are used for the display on/off.
// It will clear all composition related task and flag, and skip another
@@ -207,17 +207,17 @@ class CompositorBridgeParent final : pub
public ShmemAllocator
{
friend class CompositorVsyncScheduler;
friend class CompositorThreadHolder;
friend class InProcessCompositorSession;
friend class gfx::GPUProcessManager;
public:
- explicit CompositorBridgeParent(widget::CompositorWidgetProxy* aWidget,
+ explicit CompositorBridgeParent(widget::CompositorWidget* aWidget,
CSSToLayoutDeviceScale aScale,
bool aUseAPZ,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
virtual bool RecvGetFrameUniformity(FrameUniformityData* aOutData) override;
virtual bool RecvRequestOverfill() override;
virtual bool RecvWillClose() override;
@@ -459,17 +459,17 @@ public:
/**
* Used by the profiler to denote when a vsync occured
*/
static void PostInsertVsyncProfilerMarker(mozilla::TimeStamp aVsyncTimestamp);
float ComputeRenderIntegrity();
- widget::CompositorWidgetProxy* GetWidgetProxy() { return mWidgetProxy; }
+ widget::CompositorWidget* GetWidget() { return mWidget; }
void ForceComposeToTarget(gfx::DrawTarget* aTarget, const gfx::IntRect* aRect = nullptr);
bool AsyncPanZoomEnabled() const {
return !!mApzcTreeManager;
}
private:
@@ -581,17 +581,17 @@ protected:
// The indirect layer tree lock must be held before calling this function.
// Callback should take (LayerTreeState* aState, const uint64_t& aLayersId)
template <typename Lambda>
inline void ForEachIndirectLayerTree(const Lambda& aCallback);
RefPtr<LayerManagerComposite> mLayerManager;
RefPtr<Compositor> mCompositor;
RefPtr<AsyncCompositionManager> mCompositionManager;
- widget::CompositorWidgetProxy* mWidgetProxy;
+ widget::CompositorWidget* mWidget;
TimeStamp mTestTime;
bool mIsTesting;
uint64_t mPendingTransaction;
bool mPaused;
bool mUseExternalSurfaceSize;
--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
@@ -79,17 +79,17 @@ CompositorOGL::BindBackdrop(ShaderProgra
mGLContext->fActiveTexture(aTexUnit);
mGLContext->fBindTexture(LOCAL_GL_TEXTURE_2D, aBackdrop);
mGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_LINEAR);
mGLContext->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_LINEAR);
aProgram->SetBackdropTextureUnit(aTexUnit - LOCAL_GL_TEXTURE0);
}
CompositorOGL::CompositorOGL(CompositorBridgeParent* aParent,
- widget::CompositorWidgetProxy* aWidget,
+ widget::CompositorWidget* aWidget,
int aSurfaceWidth, int aSurfaceHeight,
bool aUseExternalSurfaceSize)
: Compositor(aWidget, aParent)
, mWidgetSize(-1, -1)
, mSurfaceSize(aSurfaceWidth, aSurfaceHeight)
, mHasBGRA(0)
, mUseExternalSurfaceSize(aUseExternalSurfaceSize)
, mFrameInProgress(false)
@@ -613,17 +613,17 @@ CompositingRenderTarget*
CompositorOGL::GetCurrentRenderTarget() const
{
return mCurrentRenderTarget;
}
static GLenum
GetFrameBufferInternalFormat(GLContext* gl,
GLuint aFrameBuffer,
- mozilla::widget::CompositorWidgetProxy* aWidget)
+ mozilla::widget::CompositorWidget* aWidget)
{
if (aFrameBuffer == 0) { // default framebuffer
return aWidget->GetGLFrameBufferFormat();
}
return LOCAL_GL_RGBA;
}
void
--- a/gfx/layers/opengl/CompositorOGL.h
+++ b/gfx/layers/opengl/CompositorOGL.h
@@ -188,17 +188,17 @@ class CompositorOGL final : public Compo
typedef mozilla::gl::GLContext GLContext;
friend class GLManagerCompositor;
friend class CompositingRenderTargetOGL;
std::map<ShaderConfigOGL, ShaderProgramOGL*> mPrograms;
public:
explicit CompositorOGL(CompositorBridgeParent* aParent,
- widget::CompositorWidgetProxy* aWidget,
+ widget::CompositorWidget* aWidget,
int aSurfaceWidth = -1, int aSurfaceHeight = -1,
bool aUseExternalSurfaceSize = false);
protected:
virtual ~CompositorOGL();
public:
virtual CompositorOGL* AsCompositorOGL() override { return this; }
--- a/gfx/tests/gtest/TestCompositor.cpp
+++ b/gfx/tests/gtest/TestCompositor.cpp
@@ -94,31 +94,31 @@ private:
~MockWidget() {}
};
NS_IMPL_ISUPPORTS_INHERITED0(MockWidget, nsBaseWidget)
struct LayerManagerData {
RefPtr<MockWidget> mWidget;
RefPtr<Compositor> mCompositor;
- RefPtr<widget::CompositorWidgetProxy> mCompositorWidgetProxy;
+ RefPtr<widget::CompositorWidget> mCompositorWidget;
RefPtr<LayerManagerComposite> mLayerManager;
LayerManagerData(Compositor* compositor,
MockWidget* widget,
- widget::CompositorWidgetProxy* aProxy,
+ widget::CompositorWidget* aWidget,
LayerManagerComposite* layerManager)
: mWidget(widget)
, mCompositor(compositor)
- , mCompositorWidgetProxy(aProxy)
+ , mCompositorWidget(aWidget)
, mLayerManager(layerManager)
{}
};
-static already_AddRefed<Compositor> CreateTestCompositor(LayersBackend backend, widget::CompositorWidgetProxy* widget)
+static already_AddRefed<Compositor> CreateTestCompositor(LayersBackend backend, widget::CompositorWidget* widget)
{
gfxPrefs::GetSingleton();
RefPtr<Compositor> compositor;
if (backend == LayersBackend::LAYERS_OPENGL) {
compositor = new CompositorOGL(nullptr,
widget,
@@ -152,17 +152,17 @@ static already_AddRefed<Compositor> Crea
static std::vector<LayerManagerData> GetLayerManagers(std::vector<LayersBackend> aBackends)
{
std::vector<LayerManagerData> managers;
for (size_t i = 0; i < aBackends.size(); i++) {
auto backend = aBackends[i];
RefPtr<MockWidget> widget = new MockWidget();
- RefPtr<widget::CompositorWidgetProxy> proxy = widget->NewCompositorWidgetProxy();
+ RefPtr<widget::CompositorWidget> proxy = widget->NewCompositorWidget();
RefPtr<Compositor> compositor = CreateTestCompositor(backend, proxy);
RefPtr<LayerManagerComposite> layerManager = new LayerManagerComposite(compositor);
managers.push_back(LayerManagerData(compositor, widget, proxy, layerManager));
}
return managers;
rename from widget/CompositorWidgetProxy.cpp
rename to widget/CompositorWidget.cpp
--- a/widget/CompositorWidgetProxy.cpp
+++ b/widget/CompositorWidget.cpp
@@ -1,40 +1,40 @@
/* 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 "CompositorWidget.h"
#include "GLConsts.h"
#include "nsBaseWidget.h"
#include "VsyncDispatcher.h"
namespace mozilla {
namespace widget {
-CompositorWidgetProxy::~CompositorWidgetProxy()
+CompositorWidget::~CompositorWidget()
{
}
already_AddRefed<gfx::DrawTarget>
-CompositorWidgetProxy::StartRemoteDrawing()
+CompositorWidget::StartRemoteDrawing()
{
return nullptr;
}
void
-CompositorWidgetProxy::CleanupRemoteDrawing()
+CompositorWidget::CleanupRemoteDrawing()
{
mLastBackBuffer = nullptr;
}
already_AddRefed<gfx::DrawTarget>
-CompositorWidgetProxy::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
- const LayoutDeviceIntRect& aRect,
- const LayoutDeviceIntRect& aClearRect)
+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;
@@ -53,134 +53,134 @@ CompositorWidgetProxy::GetBackBufferDraw
} else {
target = aScreenTarget->CreateSimilarDrawTarget(size, format);
mLastBackBuffer = target;
}
return target.forget();
}
already_AddRefed<gfx::SourceSurface>
-CompositorWidgetProxy::EndBackBufferDrawing()
+CompositorWidget::EndBackBufferDrawing()
{
RefPtr<gfx::SourceSurface> surface = mLastBackBuffer ? mLastBackBuffer->Snapshot() : nullptr;
return surface.forget();
}
uint32_t
-CompositorWidgetProxy::GetGLFrameBufferFormat()
+CompositorWidget::GetGLFrameBufferFormat()
{
return LOCAL_GL_RGBA;
}
-CompositorWidgetProxyWrapper::CompositorWidgetProxyWrapper(nsBaseWidget* aWidget)
+InProcessCompositorWidget::InProcessCompositorWidget(nsBaseWidget* aWidget)
: mWidget(aWidget)
{
}
bool
-CompositorWidgetProxyWrapper::PreRender(layers::LayerManagerComposite* aManager)
+InProcessCompositorWidget::PreRender(layers::LayerManagerComposite* aManager)
{
return mWidget->PreRender(aManager);
}
void
-CompositorWidgetProxyWrapper::PostRender(layers::LayerManagerComposite* aManager)
+InProcessCompositorWidget::PostRender(layers::LayerManagerComposite* aManager)
{
mWidget->PostRender(aManager);
}
void
-CompositorWidgetProxyWrapper::DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
- LayoutDeviceIntRect aRect)
+InProcessCompositorWidget::DrawWindowUnderlay(layers::LayerManagerComposite* aManager,
+ LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowUnderlay(aManager, aRect);
}
void
-CompositorWidgetProxyWrapper::DrawWindowOverlay(layers::LayerManagerComposite* aManager,
- LayoutDeviceIntRect aRect)
+InProcessCompositorWidget::DrawWindowOverlay(layers::LayerManagerComposite* aManager,
+ LayoutDeviceIntRect aRect)
{
mWidget->DrawWindowOverlay(aManager, aRect);
}
already_AddRefed<gfx::DrawTarget>
-CompositorWidgetProxyWrapper::StartRemoteDrawing()
+InProcessCompositorWidget::StartRemoteDrawing()
{
return mWidget->StartRemoteDrawing();
}
already_AddRefed<gfx::DrawTarget>
-CompositorWidgetProxyWrapper::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
- layers::BufferMode* aBufferMode)
+InProcessCompositorWidget::StartRemoteDrawingInRegion(LayoutDeviceIntRegion& aInvalidRegion,
+ layers::BufferMode* aBufferMode)
{
return mWidget->StartRemoteDrawingInRegion(aInvalidRegion, aBufferMode);
}
void
-CompositorWidgetProxyWrapper::EndRemoteDrawing()
+InProcessCompositorWidget::EndRemoteDrawing()
{
mWidget->EndRemoteDrawing();
}
void
-CompositorWidgetProxyWrapper::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
- LayoutDeviceIntRegion& aInvalidRegion)
+InProcessCompositorWidget::EndRemoteDrawingInRegion(gfx::DrawTarget* aDrawTarget,
+ LayoutDeviceIntRegion& aInvalidRegion)
{
mWidget->EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion);
}
void
-CompositorWidgetProxyWrapper::CleanupRemoteDrawing()
+InProcessCompositorWidget::CleanupRemoteDrawing()
{
mWidget->CleanupRemoteDrawing();
}
void
-CompositorWidgetProxyWrapper::CleanupWindowEffects()
+InProcessCompositorWidget::CleanupWindowEffects()
{
mWidget->CleanupWindowEffects();
}
bool
-CompositorWidgetProxyWrapper::InitCompositor(layers::Compositor* aCompositor)
+InProcessCompositorWidget::InitCompositor(layers::Compositor* aCompositor)
{
return mWidget->InitCompositor(aCompositor);
}
LayoutDeviceIntSize
-CompositorWidgetProxyWrapper::GetClientSize()
+InProcessCompositorWidget::GetClientSize()
{
return mWidget->GetClientSize();
}
uint32_t
-CompositorWidgetProxyWrapper::GetGLFrameBufferFormat()
+InProcessCompositorWidget::GetGLFrameBufferFormat()
{
return mWidget->GetGLFrameBufferFormat();
}
layers::Composer2D*
-CompositorWidgetProxyWrapper::GetComposer2D()
+InProcessCompositorWidget::GetComposer2D()
{
return mWidget->GetComposer2D();
}
uintptr_t
-CompositorWidgetProxyWrapper::GetWidgetKey()
+InProcessCompositorWidget::GetWidgetKey()
{
return reinterpret_cast<uintptr_t>(mWidget);
}
nsIWidget*
-CompositorWidgetProxyWrapper::RealWidget()
+InProcessCompositorWidget::RealWidget()
{
return mWidget;
}
already_AddRefed<CompositorVsyncDispatcher>
-CompositorWidgetProxyWrapper::GetCompositorVsyncDispatcher()
+InProcessCompositorWidget::GetCompositorVsyncDispatcher()
{
RefPtr<CompositorVsyncDispatcher> cvd = mWidget->GetCompositorVsyncDispatcher();
return cvd.forget();
}
} // namespace widget
} // namespace mozilla
rename from widget/CompositorWidgetProxy.h
rename to widget/CompositorWidget.h
--- a/widget/CompositorWidgetProxy.h
+++ b/widget/CompositorWidget.h
@@ -1,14 +1,14 @@
/* 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_CompositorWidgetProxy_h__
-#define mozilla_widget_CompositorWidgetProxy_h__
+#ifndef mozilla_widget_CompositorWidget_h__
+#define mozilla_widget_CompositorWidget_h__
#include "nsISupports.h"
#include "mozilla/RefPtr.h"
#include "Units.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/layers/LayersTypes.h"
class nsIWidget;
@@ -23,25 +23,25 @@ class Compositor;
class Composer2D;
} // namespace layers
namespace gfx {
class DrawTarget;
class SourceSurface;
} // namespace gfx
namespace widget {
-class WinCompositorWidgetProxy;
+class WinCompositorWidget;
/**
* Access to a widget from the compositor is restricted to these methods.
*/
-class CompositorWidgetProxy
+class CompositorWidget
{
public:
- NS_INLINE_DECL_REFCOUNTING(mozilla::widget::CompositorWidgetProxy)
+ NS_INLINE_DECL_REFCOUNTING(mozilla::widget::CompositorWidget)
/**
* Called before rendering using OMTC. Returns false when the widget is
* not ready to be rendered (for example while the window is closed).
*
* Always called from the compositing thread, which may be the main-thread if
* OMTC is not enabled.
*/
@@ -195,33 +195,33 @@ public:
*/
virtual already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing();
/**
* Return a compositor vsync dispatcher for this widget.
*/
virtual already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() = 0;
- virtual WinCompositorWidgetProxy* AsWindowsProxy() {
+ virtual WinCompositorWidget* AsWindows() {
return nullptr;
}
protected:
- virtual ~CompositorWidgetProxy();
+ virtual ~CompositorWidget();
// Back buffer of BasicCompositor
RefPtr<gfx::DrawTarget> mLastBackBuffer;
};
-// This version of CompositorWidgetProxy implements a wrapper around
+// This version of CompositorWidget implements a wrapper around
// nsBaseWidget.
-class CompositorWidgetProxyWrapper : public CompositorWidgetProxy
+class InProcessCompositorWidget : public CompositorWidget
{
public:
- explicit CompositorWidgetProxyWrapper(nsBaseWidget* aWidget);
+ 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;
@@ -235,17 +235,17 @@ public:
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.
+ // If you can override this method, inherit from CompositorWidget instead.
nsIWidget* RealWidget() override;
private:
nsBaseWidget* mWidget;
};
} // namespace widget
} // namespace mozilla
--- a/widget/PuppetWidget.h
+++ b/widget/PuppetWidget.h
@@ -275,17 +275,17 @@ public:
const bool aIsVertical,
const LayoutDeviceIntPoint& aPoint) override;
protected:
virtual nsresult NotifyIMEInternal(
const IMENotification& aIMENotification) override;
// PuppetWidgets do not create compositors.
- widget::CompositorWidgetProxy* NewCompositorWidgetProxy() override {
+ widget::CompositorWidget* NewCompositorWidget() override {
MOZ_ASSERT_UNREACHABLE("PuppetWidgets should not have widget proxies");
return nullptr;
}
private:
nsresult Paint();
void SetChild(PuppetWidget* aChild);
--- a/widget/cocoa/nsCocoaWindow.h
+++ b/widget/cocoa/nsCocoaWindow.h
@@ -348,17 +348,17 @@ public:
const mozilla::WidgetKeyboardEvent& aEvent,
DoCommandCallback aCallback,
void* aCallbackData) override;
void SetPopupWindowLevel();
NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent) override;
- CompositorWidgetProxy* NewCompositorWidgetProxy() override {
+ CompositorWidget* NewCompositorWidget() override {
return nullptr;
}
protected:
virtual ~nsCocoaWindow();
nsresult CreateNativeWindow(const NSRect &aRect,
nsBorderStyle aBorderStyle,
--- a/widget/moz.build
+++ b/widget/moz.build
@@ -83,17 +83,16 @@ XPIDL_SOURCES += [
'nsIScreenManager.idl',
'nsISound.idl',
'nsITransferable.idl',
]
XPIDL_MODULE = 'widget'
EXPORTS += [
- 'CompositorWidgetProxy.h',
'GfxDriverInfo.h',
'GfxInfoBase.h',
'GfxInfoCollector.h',
'InputData.h',
'nsBaseScreen.h',
'nsBaseWidget.h',
'nsIDeviceContextSpec.h',
'nsIKeyEventInPluginCallback.h',
@@ -124,23 +123,24 @@ EXPORTS.mozilla += [
'TextEvents.h',
'TextRange.h',
'TouchEvents.h',
'VsyncDispatcher.h',
'WidgetUtils.h',
]
EXPORTS.mozilla.widget += [
+ 'CompositorWidget.h',
'IMEData.h',
'PuppetBidiKeyboard.h',
'WidgetMessageUtils.h',
]
UNIFIED_SOURCES += [
- 'CompositorWidgetProxy.cpp',
+ 'CompositorWidget.cpp',
'ContentCache.cpp',
'GfxDriverInfo.cpp',
'GfxInfoBase.cpp',
'GfxInfoCollector.cpp',
'GfxInfoWebGL.cpp',
'InputData.cpp',
'nsBaseAppShell.cpp',
'nsBaseScreen.cpp',
--- a/widget/nsBaseWidget.cpp
+++ b/widget/nsBaseWidget.cpp
@@ -277,17 +277,17 @@ void nsBaseWidget::DestroyCompositor()
// 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;
+ mCompositorWidget = nullptr;
}
// Can have base widgets that are things like tooltips
// which don't have CompositorVsyncDispatchers
if (mCompositorVsyncDispatcher) {
mCompositorVsyncDispatcher->Shutdown();
mCompositorVsyncDispatcher = nullptr;
}
@@ -1301,25 +1301,25 @@ void nsBaseWidget::CreateCompositor(int
// If we've already received a shutdown notification, don't try
// create a new compositor.
if (!mShutdownObserver) {
return;
}
CreateCompositorVsyncDispatcher();
- if (!mCompositorWidgetProxy) {
- mCompositorWidgetProxy = NewCompositorWidgetProxy();
+ if (!mCompositorWidget) {
+ mCompositorWidget = NewCompositorWidget();
}
RefPtr<ClientLayerManager> lm = new ClientLayerManager(this);
gfx::GPUProcessManager* gpu = gfx::GPUProcessManager::Get();
mCompositorSession = gpu->CreateTopLevelCompositor(
- mCompositorWidgetProxy,
+ mCompositorWidget,
lm,
GetDefaultScale(),
UseAPZ(),
UseExternalCompositingSurface(),
gfx::IntSize(aWidth, aHeight));
mCompositorBridgeChild = mCompositorSession->GetCompositorBridgeChild();
mAPZC = mCompositorSession->GetAPZCTreeManager();
@@ -1415,20 +1415,20 @@ nsBaseWidget::StartRemoteDrawing()
}
uint32_t
nsBaseWidget::GetGLFrameBufferFormat()
{
return LOCAL_GL_RGBA;
}
-mozilla::widget::CompositorWidgetProxy*
-nsBaseWidget::NewCompositorWidgetProxy()
+mozilla::widget::CompositorWidget*
+nsBaseWidget::NewCompositorWidget()
{
- return new mozilla::widget::CompositorWidgetProxyWrapper(this);
+ return new mozilla::widget::InProcessCompositorWidget(this);
}
//-------------------------------------------------------------------------
//
// Destroy the window
//
//-------------------------------------------------------------------------
void nsBaseWidget::OnDestroy()
--- a/widget/nsBaseWidget.h
+++ b/widget/nsBaseWidget.h
@@ -16,17 +16,16 @@
#include "nsIFile.h"
#include "nsString.h"
#include "nsCOMPtr.h"
#include "nsIRollupListener.h"
#include "nsIObserver.h"
#include "nsIWidgetListener.h"
#include "nsPIDOMWindow.h"
#include "nsWeakReference.h"
-#include "CompositorWidgetProxy.h"
#include <algorithm>
class nsIContent;
class nsAutoRollup;
class gfxContext;
namespace mozilla {
class CompositorVsyncDispatcher;
#ifdef ACCESSIBILITY
@@ -45,16 +44,21 @@ class CompositorBridgeChild;
class CompositorBridgeParent;
class APZCTreeManager;
class GeckoContentController;
class APZEventState;
class CompositorSession;
struct ScrollableLayerGuid;
} // namespace layers
+namespace widget {
+class CompositorWidget;
+class InProcessCompositorWidget;
+} // namespace widget
+
class CompositorVsyncDispatcher;
} // namespace mozilla
namespace base {
class Thread;
} // namespace base
// Windows specific constant indicating the maximum number of touch points the
@@ -90,34 +94,34 @@ public:
* (Note: widget implementations are not required to use this
* class, but it gives them a head start.)
*/
class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference
{
friend class nsAutoRollup;
friend class DispatchWheelEventOnMainThread;
- friend class mozilla::widget::CompositorWidgetProxyWrapper;
+ friend class mozilla::widget::InProcessCompositorWidget;
protected:
typedef base::Thread Thread;
typedef mozilla::gfx::DrawTarget DrawTarget;
typedef mozilla::layers::BasicLayerManager BasicLayerManager;
typedef mozilla::layers::BufferMode BufferMode;
typedef mozilla::layers::CompositorBridgeChild CompositorBridgeChild;
typedef mozilla::layers::CompositorBridgeParent CompositorBridgeParent;
typedef mozilla::layers::APZCTreeManager APZCTreeManager;
typedef mozilla::layers::GeckoContentController GeckoContentController;
typedef mozilla::layers::ScrollableLayerGuid ScrollableLayerGuid;
typedef mozilla::layers::APZEventState APZEventState;
typedef mozilla::layers::SetAllowedTouchBehaviorCallback SetAllowedTouchBehaviorCallback;
typedef mozilla::CSSIntRect CSSIntRect;
typedef mozilla::CSSRect CSSRect;
typedef mozilla::ScreenRotation ScreenRotation;
- typedef mozilla::widget::CompositorWidgetProxy CompositorWidgetProxy;
+ typedef mozilla::widget::CompositorWidget CompositorWidget;
typedef mozilla::layers::CompositorSession CompositorSession;
virtual ~nsBaseWidget();
public:
nsBaseWidget();
NS_DECL_ISUPPORTS
@@ -345,21 +349,21 @@ public:
friend class AutoLayerManagerSetup;
virtual bool ShouldUseOffMainThreadCompositing();
static nsIRollupListener* GetActiveRollupListener();
void Shutdown();
- // Return a new CompositorWidgetProxy for this widget.
- virtual CompositorWidgetProxy* NewCompositorWidgetProxy();
+ // Return a new CompositorWidget for this widget.
+ virtual CompositorWidget* NewCompositorWidget();
protected:
- // These are methods for CompositorWidgetProxyWrapper, and should only be
+ // These are methods for CompositorWidgetWrapper, 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) {
return true;
}
virtual void PostRender(mozilla::layers::LayerManagerComposite* aManager)
{}
virtual void DrawWindowUnderlay(mozilla::layers::LayerManagerComposite* aManager,
@@ -582,17 +586,17 @@ protected:
// When this pointer is null, the widget is not clipped
mozilla::UniquePtr<LayoutDeviceIntRect[]> mClipRects;
uint32_t mClipRectCount;
nsSizeMode mSizeMode;
nsPopupLevel mPopupLevel;
nsPopupType mPopupType;
SizeConstraints mSizeConstraints;
- RefPtr<CompositorWidgetProxy> mCompositorWidgetProxy;
+ RefPtr<CompositorWidget> mCompositorWidget;
bool mUpdateCursor;
bool mUseAttachedEvents;
bool mIMEHasFocus;
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
bool mAccessibilityInUseFlag;
#endif
static nsIRollupListener* gRollupListener;
rename from widget/windows/WinCompositorWidgetProxy.cpp
rename to widget/windows/WinCompositorWidget.cpp
--- a/widget/windows/WinCompositorWidgetProxy.cpp
+++ b/widget/windows/WinCompositorWidget.cpp
@@ -1,83 +1,83 @@
/* -*- 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 "WinCompositorWidgetProxy.h"
+#include "WinCompositorWidget.h"
#include "nsWindow.h"
#include "VsyncDispatcher.h"
#include "mozilla/gfx/Point.h"
namespace mozilla {
namespace widget {
using namespace mozilla::gfx;
-WinCompositorWidgetProxy::WinCompositorWidgetProxy(HWND aWnd,
- uintptr_t aWidgetKey,
- nsTransparencyMode aMode,
- nsWindow* aWindow)
+WinCompositorWidget::WinCompositorWidget(HWND aWnd,
+ uintptr_t aWidgetKey,
+ nsTransparencyMode aMode,
+ nsWindow* aWindow)
: mWindow(aWindow),
mWidgetKey(aWidgetKey),
mWnd(aWnd),
mTransparencyMode(aMode),
mMemoryDC(nullptr),
mCompositeDC(nullptr),
mLockedBackBufferData(nullptr)
{
MOZ_ASSERT(mWnd && ::IsWindow(mWnd));
}
void
-WinCompositorWidgetProxy::OnDestroyWindow()
+WinCompositorWidget::OnDestroyWindow()
{
mTransparentSurface = nullptr;
mMemoryDC = nullptr;
}
bool
-WinCompositorWidgetProxy::PreRender(layers::LayerManagerComposite* aManager)
+WinCompositorWidget::PreRender(layers::LayerManagerComposite* aManager)
{
// This can block waiting for WM_SETTEXT to finish
// Using PreRender is unnecessarily pessimistic because
// we technically only need to block during the present call
// not all of compositor rendering
mPresentLock.Enter();
return true;
}
void
-WinCompositorWidgetProxy::PostRender(layers::LayerManagerComposite* aManager)
+WinCompositorWidget::PostRender(layers::LayerManagerComposite* aManager)
{
mPresentLock.Leave();
}
nsIWidget*
-WinCompositorWidgetProxy::RealWidget()
+WinCompositorWidget::RealWidget()
{
MOZ_ASSERT(mWindow);
return mWindow;
}
LayoutDeviceIntSize
-WinCompositorWidgetProxy::GetClientSize()
+WinCompositorWidget::GetClientSize()
{
RECT r;
if (!::GetClientRect(mWnd, &r)) {
return LayoutDeviceIntSize();
}
return LayoutDeviceIntSize(
r.right - r.left,
r.bottom - r.top);
}
already_AddRefed<gfx::DrawTarget>
-WinCompositorWidgetProxy::StartRemoteDrawing()
+WinCompositorWidget::StartRemoteDrawing()
{
MOZ_ASSERT(!mCompositeDC);
RefPtr<gfxASurface> surf;
if (mTransparencyMode == eTransparencyTransparent) {
surf = EnsureTransparentSurface();
}
@@ -103,39 +103,39 @@ WinCompositorWidgetProxy::StartRemoteDra
MOZ_ASSERT(!mCompositeDC);
mCompositeDC = dc;
return mozilla::gfx::Factory::CreateDrawTargetForCairoSurface(surf->CairoSurface(), size);
}
void
-WinCompositorWidgetProxy::EndRemoteDrawing()
+WinCompositorWidget::EndRemoteDrawing()
{
MOZ_ASSERT(!mLockedBackBufferData);
if (mTransparencyMode == eTransparencyTransparent) {
MOZ_ASSERT(mTransparentSurface);
RedrawTransparentWindow();
}
if (mCompositeDC) {
FreeWindowSurface(mCompositeDC);
}
mCompositeDC = nullptr;
}
already_AddRefed<gfx::DrawTarget>
-WinCompositorWidgetProxy::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
- const LayoutDeviceIntRect& aRect,
- const LayoutDeviceIntRect& aClearRect)
+WinCompositorWidget::GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
+ const LayoutDeviceIntRect& aRect,
+ const LayoutDeviceIntRect& aClearRect)
{
MOZ_ASSERT(!mLockedBackBufferData);
RefPtr<gfx::DrawTarget> target =
- CompositorWidgetProxy::GetBackBufferDrawTarget(aScreenTarget, aRect, aClearRect);
+ CompositorWidget::GetBackBufferDrawTarget(aScreenTarget, aRect, aClearRect);
if (!target) {
return nullptr;
}
MOZ_ASSERT(target->GetBackendType() == BackendType::CAIRO);
uint8_t* destData;
IntSize destSize;
@@ -153,107 +153,107 @@ WinCompositorWidgetProxy::GetBackBufferD
destStride,
destFormat);
mLockedBackBufferData = destData;
return dataTarget.forget();
}
already_AddRefed<gfx::SourceSurface>
-WinCompositorWidgetProxy::EndBackBufferDrawing()
+WinCompositorWidget::EndBackBufferDrawing()
{
if (mLockedBackBufferData) {
MOZ_ASSERT(mLastBackBuffer);
mLastBackBuffer->ReleaseBits(mLockedBackBufferData);
mLockedBackBufferData = nullptr;
}
- return CompositorWidgetProxy::EndBackBufferDrawing();
+ return CompositorWidget::EndBackBufferDrawing();
}
already_AddRefed<CompositorVsyncDispatcher>
-WinCompositorWidgetProxy::GetCompositorVsyncDispatcher()
+WinCompositorWidget::GetCompositorVsyncDispatcher()
{
RefPtr<CompositorVsyncDispatcher> cvd = mWindow->GetCompositorVsyncDispatcher();
return cvd.forget();
}
uintptr_t
-WinCompositorWidgetProxy::GetWidgetKey()
+WinCompositorWidget::GetWidgetKey()
{
return mWidgetKey;
}
void
-WinCompositorWidgetProxy::EnterPresentLock()
+WinCompositorWidget::EnterPresentLock()
{
mPresentLock.Enter();
}
void
-WinCompositorWidgetProxy::LeavePresentLock()
+WinCompositorWidget::LeavePresentLock()
{
mPresentLock.Leave();
}
RefPtr<gfxASurface>
-WinCompositorWidgetProxy::EnsureTransparentSurface()
+WinCompositorWidget::EnsureTransparentSurface()
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
if (!mTransparentSurface) {
LayoutDeviceIntSize size = GetClientSize();
CreateTransparentSurface(size.width, size.height);
}
RefPtr<gfxASurface> surface = mTransparentSurface;
return surface.forget();
}
void
-WinCompositorWidgetProxy::CreateTransparentSurface(int32_t aWidth, int32_t aHeight)
+WinCompositorWidget::CreateTransparentSurface(int32_t aWidth, int32_t aHeight)
{
MOZ_ASSERT(!mTransparentSurface && !mMemoryDC);
RefPtr<gfxWindowsSurface> surface =
new gfxWindowsSurface(IntSize(aWidth, aHeight), SurfaceFormat::A8R8G8B8_UINT32);
mTransparentSurface = surface;
mMemoryDC = surface->GetDC();
}
void
-WinCompositorWidgetProxy::UpdateTransparency(nsTransparencyMode aMode)
+WinCompositorWidget::UpdateTransparency(nsTransparencyMode aMode)
{
if (mTransparencyMode == aMode) {
return;
}
mTransparencyMode = aMode;
mTransparentSurface = nullptr;
mMemoryDC = nullptr;
if (mTransparencyMode == eTransparencyTransparent) {
EnsureTransparentSurface();
}
}
void
-WinCompositorWidgetProxy::ClearTransparentWindow()
+WinCompositorWidget::ClearTransparentWindow()
{
if (!mTransparentSurface) {
return;
}
IntSize size = mTransparentSurface->GetSize();
RefPtr<DrawTarget> drawTarget = gfxPlatform::GetPlatform()->
CreateDrawTargetForSurface(mTransparentSurface, size);
drawTarget->ClearRect(Rect(0, 0, size.width, size.height));
RedrawTransparentWindow();
}
void
-WinCompositorWidgetProxy::ResizeTransparentWindow(int32_t aNewWidth, int32_t aNewHeight)
+WinCompositorWidget::ResizeTransparentWindow(int32_t aNewWidth, int32_t aNewHeight)
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
if (mTransparentSurface &&
mTransparentSurface->GetSize() == IntSize(aNewWidth, aNewHeight))
{
return;
}
@@ -261,17 +261,17 @@ WinCompositorWidgetProxy::ResizeTranspar
// Destroy the old surface.
mTransparentSurface = nullptr;
mMemoryDC = nullptr;
CreateTransparentSurface(aNewWidth, aNewHeight);
}
bool
-WinCompositorWidgetProxy::RedrawTransparentWindow()
+WinCompositorWidget::RedrawTransparentWindow()
{
MOZ_ASSERT(mTransparencyMode == eTransparencyTransparent);
LayoutDeviceIntSize size = GetClientSize();
::GdiFlush();
BLENDFUNCTION bf = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
@@ -283,24 +283,24 @@ WinCompositorWidgetProxy::RedrawTranspar
// perform the alpha blend
return !!::UpdateLayeredWindow(
hWnd, nullptr, (POINT*)&winRect, &winSize, mMemoryDC,
&srcPos, 0, &bf, ULW_ALPHA);
}
HDC
-WinCompositorWidgetProxy::GetWindowSurface()
+WinCompositorWidget::GetWindowSurface()
{
return eTransparencyTransparent == mTransparencyMode
? mMemoryDC
: ::GetDC(mWnd);
}
void
-WinCompositorWidgetProxy::FreeWindowSurface(HDC dc)
+WinCompositorWidget::FreeWindowSurface(HDC dc)
{
if (eTransparencyTransparent != mTransparencyMode)
::ReleaseDC(mWnd, dc);
}
} // namespace widget
} // namespace mozilla
rename from widget/windows/WinCompositorWidgetProxy.h
rename to widget/windows/WinCompositorWidget.h
--- a/widget/windows/WinCompositorWidgetProxy.h
+++ b/widget/windows/WinCompositorWidget.h
@@ -1,49 +1,49 @@
/* -*- 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 "CompositorWidgetProxy.h"
+#include "CompositorWidget.h"
#include "mozilla/gfx/CriticalSection.h"
class nsWindow;
namespace mozilla {
namespace widget {
-// This is the Windows-specific implementation of CompositorWidgetProxy. For
+// This is the Windows-specific implementation of CompositorWidget. For
// the most part it only requires an HWND, however it maintains extra state
// for transparent windows, as well as for synchronizing WM_SETTEXT messages
// with the compositor.
-class WinCompositorWidgetProxy : public CompositorWidgetProxy
+class WinCompositorWidget: public CompositorWidget
{
public:
- WinCompositorWidgetProxy(HWND aWnd,
- uintptr_t aWidgetKey,
- nsTransparencyMode aMode,
- nsWindow* aWindow = nullptr);
+ WinCompositorWidget(HWND aWnd,
+ uintptr_t aWidgetKey,
+ nsTransparencyMode aMode,
+ nsWindow* aWindow = nullptr);
bool PreRender(layers::LayerManagerComposite*) override;
void PostRender(layers::LayerManagerComposite*) override;
already_AddRefed<gfx::DrawTarget> StartRemoteDrawing() override;
void EndRemoteDrawing() override;
LayoutDeviceIntSize GetClientSize() override;
already_AddRefed<gfx::DrawTarget> GetBackBufferDrawTarget(gfx::DrawTarget* aScreenTarget,
const LayoutDeviceIntRect& aRect,
const LayoutDeviceIntRect& aClearRect) override;
already_AddRefed<gfx::SourceSurface> EndBackBufferDrawing() override;
already_AddRefed<CompositorVsyncDispatcher> GetCompositorVsyncDispatcher() override;
uintptr_t GetWidgetKey() override;
nsIWidget* RealWidget() override;
- WinCompositorWidgetProxy* AsWindowsProxy() override {
+ WinCompositorWidget* AsWindows() override {
return this;
}
// Callbacks for nsWindow.
void EnterPresentLock();
void LeavePresentLock();
void OnDestroyWindow();
--- a/widget/windows/moz.build
+++ b/widget/windows/moz.build
@@ -9,17 +9,17 @@ TEST_DIRS += ['tests']
EXPORTS += [
'nsdefs.h',
'WindowHook.h',
'WinUtils.h',
]
EXPORTS.mozilla.widget += [
'AudioSession.h',
- 'WinCompositorWidgetProxy.h',
+ 'WinCompositorWidget.h',
'WinMessages.h',
'WinModifierKeyState.h',
'WinNativeEventData.h',
]
UNIFIED_SOURCES += [
'AudioSession.cpp',
'GfxInfo.cpp',
@@ -50,17 +50,17 @@ UNIFIED_SOURCES += [
'nsWindowDbg.cpp',
'nsWindowGfx.cpp',
'nsWinGesture.cpp',
'TaskbarPreview.cpp',
'TaskbarPreviewButton.cpp',
'TaskbarTabPreview.cpp',
'TaskbarWindowPreview.cpp',
'WidgetTraceEvent.cpp',
- 'WinCompositorWidgetProxy.cpp',
+ 'WinCompositorWidget.cpp',
'WindowHook.cpp',
'WinIMEHandler.cpp',
'WinTaskbar.cpp',
'WinTextEventDispatcherListener.cpp',
'WinUtils.cpp',
]
# The following files cannot be built in unified mode because of name clashes.
--- a/widget/windows/nsWindow.cpp
+++ b/widget/windows/nsWindow.cpp
@@ -135,17 +135,17 @@
#include "mozilla/WindowsVersion.h"
#include "mozilla/TextEvents.h" // For WidgetKeyboardEvent
#include "mozilla/TextEventDispatcherListener.h"
#include "mozilla/widget/WinNativeEventData.h"
#include "nsThemeConstants.h"
#include "nsBidiKeyboard.h"
#include "nsThemeConstants.h"
#include "gfxConfig.h"
-#include "WinCompositorWidgetProxy.h"
+#include "WinCompositorWidget.h"
#include "nsIGfxInfo.h"
#include "nsUXThemeConstants.h"
#include "KeyboardLayout.h"
#include "nsNativeDragTarget.h"
#include <mmsystem.h> // needed for WIN32_LEAN_AND_MEAN
#include <zmouse.h>
#include <richedit.h>
@@ -1286,17 +1286,17 @@ NS_METHOD nsWindow::Show(bool bState)
if (!wasVisible && (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog)) {
// when a toplevel window or dialog is shown, initialize the UI state
::SendMessageW(mWnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);
}
} else {
// Clear contents to avoid ghosting of old content if we display
// this window again.
if (wasVisible && mTransparencyMode == eTransparencyTransparent) {
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->ClearTransparentWindow();
}
}
if (mWindowType != eWindowType_dialog) {
::ShowWindow(mWnd, SW_HIDE);
} else {
::SetWindowPos(mWnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_NOACTIVATE);
@@ -1545,17 +1545,17 @@ NS_METHOD nsWindow::Resize(double aWidth
if (mBounds.width == width && mBounds.height == height) {
if (aRepaint) {
Invalidate();
}
return NS_OK;
}
if (mTransparencyMode == eTransparencyTransparent) {
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->ResizeTransparentWindow(width, height);
}
}
// Set cached value for lightweight and printing
mBounds.width = width;
mBounds.height = height;
@@ -1604,17 +1604,17 @@ NS_METHOD nsWindow::Resize(double aX, do
mBounds.width == width && mBounds.height == height) {
if (aRepaint) {
Invalidate();
}
return NS_OK;
}
if (eTransparencyTransparent == mTransparencyMode) {
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->ResizeTransparentWindow(width, height);
}
}
// Set cached value for lightweight and printing
mBounds.x = x;
mBounds.y = y;
mBounds.width = width;
@@ -3615,18 +3615,18 @@ nsWindow::GetLayerManager(PLayerTransact
CreateCompositor();
}
if (!mLayerManager) {
MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild);
// Ensure we have a widget proxy even if we're not using the compositor,
// since that's where we handle transparent windows.
- if (!mCompositorWidgetProxy) {
- mCompositorWidgetProxy = NewCompositorWidgetProxy();
+ if (!mCompositorWidget) {
+ mCompositorWidget= NewCompositorWidget();
}
mLayerManager = CreateBasicLayerManager();
}
NS_ASSERTION(mLayerManager, "Couldn't provide a valid layer manager.");
return mLayerManager;
@@ -3679,30 +3679,30 @@ nsWindow::OnDefaultButtonLoaded(const La
if (!::SetCursorPos(centerOfButton.x, centerOfButton.y)) {
NS_ERROR("SetCursorPos failed");
return NS_ERROR_FAILURE;
}
return NS_OK;
}
-mozilla::widget::CompositorWidgetProxy*
-nsWindow::NewCompositorWidgetProxy()
-{
- return new WinCompositorWidgetProxy(
+mozilla::widget::CompositorWidget*
+nsWindow::NewCompositorWidget()
+{
+ return new WinCompositorWidget(
mWnd,
reinterpret_cast<uintptr_t>(this),
mTransparencyMode,
this);
}
-mozilla::widget::WinCompositorWidgetProxy*
-nsWindow::GetCompositorWidgetProxy()
-{
- return mCompositorWidgetProxy ? mCompositorWidgetProxy->AsWindowsProxy() : nullptr;
+mozilla::widget::WinCompositorWidget*
+nsWindow::GetCompositorWidget()
+{
+ return mCompositorWidget? mCompositorWidget->AsWindows() : nullptr;
}
void
nsWindow::UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries)
{
RefPtr<LayerManager> layerManager = GetLayerManager();
if (!layerManager) {
return;
@@ -4897,17 +4897,17 @@ nsWindow::ProcessMessage(UINT msg, WPARA
{
// From msdn, the way around this is to disable the visible state
// temporarily. We need the text to be set but we don't want the
// redraw to occur. However, we need to make sure that we don't
// do this at the same time that a Present is happening.
//
// To do this we take mPresentLock in nsWindow::PreRender and
// if that lock is taken we wait before doing WM_SETTEXT
- RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy();
+ RefPtr<WinCompositorWidget> proxy = GetCompositorWidget();
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);
@@ -6208,17 +6208,17 @@ void nsWindow::OnWindowPosChanged(WINDOW
::GetWindowRect(mWnd, &r);
newWidth = r.right - r.left;
newHeight = r.bottom - r.top;
nsIntRect rect(wp->x, wp->y, newWidth, newHeight);
if (eTransparencyTransparent == mTransparencyMode) {
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->ResizeTransparentWindow(newWidth, newHeight);
}
}
if (newWidth > mLastSize.width)
{
RECT drect;
@@ -6729,17 +6729,17 @@ void nsWindow::OnDestroy()
VERIFY(::DeleteObject(mBrush));
mBrush = nullptr;
}
// Destroy any custom cursor resources.
if (mCursor == -1)
SetCursor(eCursor_standard);
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->OnDestroyWindow();
}
// Finalize panning feedback to possibly restore window displacement
mGesture.PanFeedbackFinalize(mWnd, true);
// Clear the main HWND.
mWnd = nullptr;
@@ -7046,17 +7046,17 @@ void nsWindow::SetWindowTranslucencyInne
VERIFY_WINDOW_STYLE(style);
::SetWindowLongPtrW(hWnd, GWL_STYLE, style);
::SetWindowLongPtrW(hWnd, GWL_EXSTYLE, exStyle);
if (HasGlass())
memset(&mGlassMargins, 0, sizeof mGlassMargins);
mTransparencyMode = aMode;
- if (RefPtr<WinCompositorWidgetProxy> proxy = GetCompositorWidgetProxy()) {
+ if (RefPtr<WinCompositorWidget> proxy = GetCompositorWidget()) {
proxy->UpdateTransparency(aMode);
}
UpdateGlass();
}
#endif //MOZ_XUL
/**************************************************************
--- a/widget/windows/nsWindow.h
+++ b/widget/windows/nsWindow.h
@@ -53,17 +53,17 @@
class nsNativeDragTarget;
class nsIRollupListener;
class imgIContainer;
namespace mozilla {
namespace widget {
class NativeKey;
struct MSGResult;
-class WinCompositorWidgetProxy;
+class WinCompositorWidget;
} // namespace widget
} // namespacw mozilla;
/**
* Native WIN32 window wrapper.
*/
class nsWindow : public nsWindowBase
@@ -307,17 +307,17 @@ public:
const mozilla::widget::CandidateWindowPosition&
aPosition) override;
virtual void DefaultProcOfPluginEvent(
const mozilla::WidgetPluginEvent& aEvent) override;
virtual nsresult OnWindowedPluginKeyEvent(
const mozilla::NativeEventData& aKeyEventData,
nsIKeyEventInPluginCallback* aCallback) override;
- mozilla::widget::CompositorWidgetProxy* NewCompositorWidgetProxy() override;
+ mozilla::widget::CompositorWidget* NewCompositorWidget() override;
protected:
virtual ~nsWindow();
virtual void WindowUsesOMTC() override;
virtual void RegisterTouchWindow() override;
// A magic number to identify the FAKETRACKPOINTSCROLLABLE window created
@@ -482,17 +482,17 @@ protected:
virtual nsresult SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
bool aIntersectWithExisting) override;
nsIntRegion GetRegionToPaint(bool aForceFullRepaint,
PAINTSTRUCT ps, HDC aDC);
static void ActivateOtherWindowHelper(HWND aWnd);
void ClearCachedResources();
nsIWidgetListener* GetPaintListener();
- mozilla::widget::WinCompositorWidgetProxy* GetCompositorWidgetProxy();
+ mozilla::widget::WinCompositorWidget* GetCompositorWidget();
protected:
nsCOMPtr<nsIWidget> mParent;
nsIntSize mLastSize;
nsIntPoint mLastPoint;
HWND mWnd;
HWND mTransitionWnd;
WNDPROC mPrevWndProc;
--- a/widget/windows/nsWindowGfx.cpp
+++ b/widget/windows/nsWindowGfx.cpp
@@ -234,17 +234,17 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t
// we force generation of WM_PAINT messages by invalidating window areas with
// RedrawWindow, InvalidateRect or InvalidateRgn function calls.
// BeginPaint/EndPaint must be called to make Windows think that invalid area
// is painted. Otherwise it will continue sending the same message endlessly.
::BeginPaint(mWnd, &ps);
::EndPaint(mWnd, &ps);
// We're guaranteed to have a widget proxy since we called GetLayerManager().
- aDC = GetCompositorWidgetProxy()->GetTransparentDC();
+ aDC = GetCompositorWidget()->GetTransparentDC();
}
#endif
mPainting = true;
#ifdef WIDGET_DEBUG_OUTPUT
HRGN debugPaintFlashRegion = nullptr;
HDC debugPaintFlashDC = nullptr;
@@ -308,17 +308,17 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t
switch (GetLayerManager()->GetBackendType()) {
case LayersBackend::LAYERS_BASIC:
{
RefPtr<gfxASurface> targetSurface;
#if defined(MOZ_XUL)
// don't support transparency for non-GDI rendering, for now
if (eTransparencyTransparent == mTransparencyMode) {
- targetSurface = GetCompositorWidgetProxy()->EnsureTransparentSurface();
+ targetSurface = GetCompositorWidget()->EnsureTransparentSurface();
}
#endif
RefPtr<gfxWindowsSurface> targetSurfaceWin;
if (!targetSurface)
{
uint32_t flags = (mTransparencyMode == eTransparencyOpaque) ? 0 :
gfxWindowsSurface::FLAG_IS_TRANSPARENT;
@@ -373,17 +373,17 @@ bool nsWindow::OnPaint(HDC aDC, uint32_t
this, LayoutDeviceIntRegion::FromUnknownRegion(region));
}
#ifdef MOZ_XUL
if (eTransparencyTransparent == mTransparencyMode) {
// 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.
- GetCompositorWidgetProxy()->RedrawTransparentWindow();
+ GetCompositorWidget()->RedrawTransparentWindow();
}
#endif
}
break;
case LayersBackend::LAYERS_CLIENT:
{
result = listener->PaintWindow(
this, LayoutDeviceIntRegion::FromUnknownRegion(region));