--- a/gfx/layers/ipc/PWebRenderBridge.ipdl
+++ b/gfx/layers/ipc/PWebRenderBridge.ipdl
@@ -18,17 +18,17 @@ using mozilla::layers::APZTestData from
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
using mozilla::layers::CompositableHandle from "mozilla/layers/LayersTypes.h";
using mozilla::wr::ByteBuffer from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::ExternalImageId from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::ImageKey from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::FontKey from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::PipelineId from "mozilla/webrender/WebRenderTypes.h";
-using mozilla::wr::WrBuiltDisplayListDescriptor from "mozilla/webrender/webrender_ffi.h";
+using mozilla::wr::BuiltDisplayListDescriptor from "mozilla/webrender/webrender_ffi.h";
using mozilla::layers::WebRenderScrollData from "mozilla/layers/WebRenderScrollData.h";
namespace mozilla {
namespace layers {
sync protocol PWebRenderBridge
{
manager PCompositorBridge;
@@ -50,20 +50,20 @@ parent:
async UpdateImage(ImageKey aImageKey, IntSize aSize,
SurfaceFormat aFormat, ByteBuffer aBytes);
async DeleteImage(ImageKey aImageKey);
async DeleteCompositorAnimations(uint64_t[] aIds);
async AddRawFont(FontKey aFontKey, ByteBuffer aBytes, uint32_t aFontIndex);
async DeleteFont(FontKey aFontKey);
async DPBegin(IntSize aSize);
async DPEnd(IntSize aSize, WebRenderParentCommand[] commands, OpDestroy[] toDestroy, uint64_t fwdTransactionId, uint64_t transactionId,
- LayoutSize aContentSize, ByteBuffer aDL, WrBuiltDisplayListDescriptor aDLDesc,
+ LayoutSize aContentSize, ByteBuffer aDL, BuiltDisplayListDescriptor aDLDesc,
WebRenderScrollData aScrollData, uint32_t idNameSpace);
sync DPSyncEnd(IntSize aSize, WebRenderParentCommand[] commands, OpDestroy[] toDestroy, uint64_t fwdTransactionId, uint64_t transactionId,
- LayoutSize aContentSize, ByteBuffer aDL, WrBuiltDisplayListDescriptor aDLDesc,
+ LayoutSize aContentSize, ByteBuffer aDL, BuiltDisplayListDescriptor aDLDesc,
WebRenderScrollData aScrollData, uint32_t idNameSpace);
async ParentCommands(WebRenderParentCommand[] commands);
sync DPGetSnapshot(PTexture texture);
async AddPipelineIdForAsyncCompositable(PipelineId aImageId, CompositableHandle aHandle);
async RemovePipelineIdForAsyncCompositable(PipelineId aPipelineId);
async AddExternalImageIdForCompositable(ExternalImageId aImageId, CompositableHandle aHandle);
async RemoveExternalImageId(ExternalImageId aImageId);
async SetLayerObserverEpoch(uint64_t layerObserverEpoch);
--- a/gfx/layers/ipc/WebRenderMessages.ipdlh
+++ b/gfx/layers/ipc/WebRenderMessages.ipdlh
@@ -5,18 +5,18 @@
* 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 LayersSurfaces;
include LayersMessages;
include protocol PTexture;
using mozilla::wr::LayoutSize from "mozilla/webrender/webrender_ffi.h";
-using mozilla::wr::WrImageRendering from "mozilla/webrender/webrender_ffi.h";
-using mozilla::wr::WrMixBlendMode from "mozilla/webrender/webrender_ffi.h";
+using mozilla::wr::ImageRendering from "mozilla/webrender/webrender_ffi.h";
+using mozilla::wr::MixBlendMode from "mozilla/webrender/webrender_ffi.h";
using mozilla::wr::MaybeImageMask from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::ExternalImageId from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::ImageKey from "mozilla/webrender/WebRenderTypes.h";
using mozilla::wr::PipelineId from "mozilla/webrender/WebRenderTypes.h";
using mozilla::gfx::MaybeIntSize from "mozilla/gfx/Point.h";
using mozilla::LayerPoint from "Units.h";
using mozilla::layers::MaybeLayerRect from "mozilla/layers/LayersTypes.h";
using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
@@ -46,18 +46,18 @@ struct OpAddCompositorAnimations {
OptionalOpacity opacity;
};
struct OpUpdateAsyncImagePipeline {
PipelineId pipelineId;
LayerRect scBounds;
Matrix4x4 scTransform;
MaybeIntSize scaleToSize;
- WrImageRendering filter;
- WrMixBlendMode mixBlendMode;
+ ImageRendering filter;
+ MixBlendMode mixBlendMode;
};
union WebRenderParentCommand {
OpAddExternalImage;
OpUpdateAsyncImagePipeline;
CompositableOperation;
OpAddCompositorAnimations;
};
--- a/gfx/layers/wr/StackingContextHelper.cpp
+++ b/gfx/layers/wr/StackingContextHelper.cpp
@@ -31,19 +31,19 @@ StackingContextHelper::StackingContextHe
if (aTransformPtr) {
mTransform = *aTransformPtr;
}
mBuilder->PushStackingContext(scBounds,
aAnimationsId,
aOpacityPtr,
aTransformPtr,
- wr::WrTransformStyle::Flat,
+ wr::TransformStyle::Flat,
// TODO: set correct blend mode.
- wr::ToWrMixBlendMode(gfx::CompositionOp::OP_OVER),
+ wr::ToMixBlendMode(gfx::CompositionOp::OP_OVER),
aFilters);
mOrigin = aOrigin;
}
StackingContextHelper::StackingContextHelper(const StackingContextHelper& aParentSC,
wr::DisplayListBuilder& aBuilder,
WebRenderLayer* aLayer,
@@ -53,18 +53,18 @@ StackingContextHelper::StackingContextHe
{
wr::LayoutRect scBounds = aParentSC.ToRelativeLayoutRect(aLayer->BoundsForStackingContext());
Layer* layer = aLayer->GetLayer();
mTransform = aTransform.valueOr(layer->GetTransform());
float opacity = 1.0f;
mBuilder->PushStackingContext(scBounds, 0, &opacity,
mTransform.IsIdentity() ? nullptr : &mTransform,
- wr::WrTransformStyle::Flat,
- wr::ToWrMixBlendMode(layer->GetMixBlendMode()),
+ wr::TransformStyle::Flat,
+ wr::ToMixBlendMode(layer->GetMixBlendMode()),
aFilters);
mOrigin = aLayer->Bounds().TopLeft();
}
StackingContextHelper::StackingContextHelper(const StackingContextHelper& aParentSC,
wr::DisplayListBuilder& aBuilder,
WebRenderLayer* aLayer,
uint64_t aAnimationsId,
@@ -77,18 +77,18 @@ StackingContextHelper::StackingContextHe
if (aTransformPtr) {
mTransform = *aTransformPtr;
}
mBuilder->PushStackingContext(scBounds,
aAnimationsId,
aOpacityPtr,
aTransformPtr,
- wr::WrTransformStyle::Flat,
- wr::ToWrMixBlendMode(aLayer->GetLayer()->GetMixBlendMode()),
+ wr::TransformStyle::Flat,
+ wr::ToMixBlendMode(aLayer->GetLayer()->GetMixBlendMode()),
aFilters);
mOrigin = aLayer->Bounds().TopLeft();
}
StackingContextHelper::~StackingContextHelper()
{
if (mBuilder) {
mBuilder->PopStackingContext();
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -397,17 +397,17 @@ WebRenderBridgeParent::RecvDPBegin(const
void
WebRenderBridgeParent::HandleDPEnd(const gfx::IntSize& aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace)
{
AutoProfilerTracing tracing("Paint", "DPTransaction");
UpdateFwdTransactionId(aFwdTransactionId);
AutoClearReadLocks clearLocks(mReadLocks);
if (mDestroyed) {
@@ -510,17 +510,17 @@ WebRenderBridgeParent::GetScrollData() c
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvDPEnd(const gfx::IntSize& aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace)
{
if (mDestroyed) {
return IPC_OK();
}
HandleDPEnd(aSize, Move(aCommands), Move(aToDestroy), aFwdTransactionId, aTransactionId,
aContentSize, dl, dlDesc, aScrollData, aIdNameSpace);
@@ -530,17 +530,17 @@ WebRenderBridgeParent::RecvDPEnd(const g
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvDPSyncEnd(const gfx::IntSize &aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace)
{
if (mDestroyed) {
return IPC_OK();
}
HandleDPEnd(aSize, Move(aCommands), Move(aToDestroy), aFwdTransactionId, aTransactionId,
aContentSize, dl, dlDesc, aScrollData, aIdNameSpace);
@@ -652,17 +652,17 @@ WebRenderBridgeParent::ProcessWebRenderP
}
}
}
void
WebRenderBridgeParent::ProcessWebRenderCommands(const gfx::IntSize &aSize,
InfallibleTArray<WebRenderParentCommand>& aCommands, const wr::Epoch& aEpoch,
const wr::LayoutSize& aContentSize, const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const uint32_t& aIdNameSpace)
{
mCompositableHolder->SetCompositionTime(TimeStamp::Now());
ProcessWebRenderParentCommands(aCommands);
// The command is obsoleted.
// Do not set the command to webrender since it causes crash in webrender.
if (mIdNameSpace != aIdNameSpace) {
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -95,27 +95,27 @@ public:
mozilla::ipc::IPCResult RecvDPBegin(const gfx::IntSize& aSize) override;
mozilla::ipc::IPCResult RecvDPEnd(const gfx::IntSize& aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace) override;
mozilla::ipc::IPCResult RecvDPSyncEnd(const gfx::IntSize& aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace) override;
mozilla::ipc::IPCResult RecvParentCommands(nsTArray<WebRenderParentCommand>&& commands) override;
mozilla::ipc::IPCResult RecvDPGetSnapshot(PTextureParent* aTexture) override;
mozilla::ipc::IPCResult RecvAddPipelineIdForAsyncCompositable(const wr::PipelineId& aPipelineIds,
const CompositableHandle& aHandle) override;
mozilla::ipc::IPCResult RecvRemovePipelineIdForAsyncCompositable(const wr::PipelineId& aPipelineId) override;
@@ -214,29 +214,29 @@ private:
uint64_t GetLayersId() const;
void DeleteOldImages();
void ProcessWebRenderParentCommands(InfallibleTArray<WebRenderParentCommand>& aCommands);
void ProcessWebRenderCommands(const gfx::IntSize &aSize,
InfallibleTArray<WebRenderParentCommand>& commands,
const wr::Epoch& aEpoch,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const uint32_t& aIdNameSpace);
void ClearResources();
uint64_t GetChildLayerObserverEpoch() const { return mChildLayerObserverEpoch; }
bool ShouldParentObserveEpoch();
void HandleDPEnd(const gfx::IntSize& aSize,
InfallibleTArray<WebRenderParentCommand>&& aCommands,
InfallibleTArray<OpDestroy>&& aToDestroy,
const uint64_t& aFwdTransactionId,
const uint64_t& aTransactionId,
const wr::LayoutSize& aContentSize,
const wr::ByteBuffer& dl,
- const wr::WrBuiltDisplayListDescriptor& dlDesc,
+ const wr::BuiltDisplayListDescriptor& dlDesc,
const WebRenderScrollData& aScrollData,
const uint32_t& aIdNameSpace);
mozilla::ipc::IPCResult HandleShutdown();
void AdvanceAnimations();
void SampleAnimations(nsTArray<wr::WrOpacityProperty>& aOpacityArray,
nsTArray<wr::WrTransformProperty>& aTransformArray);
--- a/gfx/layers/wr/WebRenderCompositableHolder.cpp
+++ b/gfx/layers/wr/WebRenderCompositableHolder.cpp
@@ -14,18 +14,18 @@
namespace mozilla {
namespace layers {
WebRenderCompositableHolder::AsyncImagePipelineHolder::AsyncImagePipelineHolder()
: mInitialised(false)
, mIsChanged(false)
, mUseExternalImage(false)
- , mFilter(wr::WrImageRendering::Auto)
- , mMixBlendMode(wr::WrMixBlendMode::Normal)
+ , mFilter(wr::ImageRendering::Auto)
+ , mMixBlendMode(wr::MixBlendMode::Normal)
{}
WebRenderCompositableHolder::WebRenderCompositableHolder(uint32_t aIdNamespace)
: mIdNamespace(aIdNamespace)
, mResourceId(0)
, mAsyncImageEpoch(0)
, mDestroyed(false)
{
@@ -130,18 +130,18 @@ WebRenderCompositableHolder::RemoveAsync
}
}
void
WebRenderCompositableHolder::UpdateAsyncImagePipeline(const wr::PipelineId& aPipelineId,
const LayerRect& aScBounds,
const gfx::Matrix4x4& aScTransform,
const gfx::MaybeIntSize& aScaleToSize,
- const wr::WrImageRendering& aFilter,
- const wr::WrMixBlendMode& aMixBlendMode)
+ const wr::ImageRendering& aFilter,
+ const wr::MixBlendMode& aMixBlendMode)
{
if (mDestroyed) {
return;
}
AsyncImagePipelineHolder* holder = mAsyncImagePipelineHolders.Get(wr::AsUint64(aPipelineId));
if (!holder) {
return;
}
@@ -270,17 +270,17 @@ WebRenderCompositableHolder::ApplyAsyncI
if (!keys.IsEmpty()) {
MOZ_ASSERT(holder->mCurrentTexture.get());
float opacity = 1.0f;
builder.PushStackingContext(wr::ToLayoutRect(holder->mScBounds),
0,
&opacity,
holder->mScTransform.IsIdentity() ? nullptr : &holder->mScTransform,
- wr::WrTransformStyle::Flat,
+ wr::TransformStyle::Flat,
holder->mMixBlendMode,
nsTArray<wr::WrFilterOp>());
LayerRect rect(0, 0, holder->mCurrentTexture->GetSize().width, holder->mCurrentTexture->GetSize().height);
if (holder->mScaleToSize.isSome()) {
rect = LayerRect(0, 0, holder->mScaleToSize.value().width, holder->mScaleToSize.value().height);
}
--- a/gfx/layers/wr/WebRenderCompositableHolder.h
+++ b/gfx/layers/wr/WebRenderCompositableHolder.h
@@ -70,18 +70,18 @@ public:
void AddAsyncImagePipeline(const wr::PipelineId& aPipelineId, WebRenderImageHost* aImageHost);
void RemoveAsyncImagePipeline(wr::WebRenderAPI* aApi, const wr::PipelineId& aPipelineId);
void UpdateAsyncImagePipeline(const wr::PipelineId& aPipelineId,
const LayerRect& aScBounds,
const gfx::Matrix4x4& aScTransform,
const gfx::MaybeIntSize& aScaleToSize,
- const wr::WrImageRendering& aFilter,
- const wr::WrMixBlendMode& aMixBlendMode);
+ const wr::ImageRendering& aFilter,
+ const wr::MixBlendMode& aMixBlendMode);
void ApplyAsyncImages(wr::WebRenderAPI* aApi);
private:
void DeleteOldAsyncImages(wr::WebRenderAPI* aApi);
uint32_t GetNextResourceId() { return ++mResourceId; }
uint32_t GetNamespace() { return mIdNamespace; }
wr::ImageKey GetImageKey()
@@ -112,18 +112,18 @@ private:
AsyncImagePipelineHolder();
bool mInitialised;
bool mIsChanged;
bool mUseExternalImage;
LayerRect mScBounds;
gfx::Matrix4x4 mScTransform;
gfx::MaybeIntSize mScaleToSize;
- wr::WrImageRendering mFilter;
- wr::WrMixBlendMode mMixBlendMode;
+ wr::ImageRendering mFilter;
+ wr::MixBlendMode mMixBlendMode;
RefPtr<WebRenderImageHost> mImageHost;
CompositableTextureHostRef mCurrentTexture;
nsTArray<wr::ImageKey> mKeys;
};
bool UpdateImageKeys(wr::WebRenderAPI* aApi,
bool& aUseExternalImage,
AsyncImagePipelineHolder* aHolder,
--- a/gfx/layers/wr/WebRenderImageLayer.cpp
+++ b/gfx/layers/wr/WebRenderImageLayer.cpp
@@ -172,17 +172,17 @@ WebRenderImageLayer::RenderLayer(wr::Dis
MaybeIntSize scaleToSize;
if (mScaleMode != ScaleMode::SCALE_NONE) {
NS_ASSERTION(mScaleMode == ScaleMode::STRETCH,
"No other scalemodes than stretch and none supported yet.");
scaleToSize = Some(mScaleToSize);
}
LayerRect scBounds = BoundsForStackingContext();
wr::ImageRendering filter = wr::ToImageRendering(mSamplingFilter);
- wr::MixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetMixBlendMode());
+ wr::MixBlendMode mixBlendMode = wr::ToMixBlendMode(GetMixBlendMode());
WrBridge()->AddWebRenderParentCommand(OpUpdateAsyncImagePipeline(mPipelineId.value(),
scBounds,
scTransform,
scaleToSize,
filter,
mixBlendMode));
return;
--- a/gfx/layers/wr/WebRenderLayer.cpp
+++ b/gfx/layers/wr/WebRenderLayer.cpp
@@ -121,17 +121,17 @@ WebRenderLayer::DumpLayerInfo(const char
{
if (!gfxPrefs::LayersDump()) {
return;
}
Layer* layer = GetLayer();
Matrix4x4 transform = layer->GetTransform();
LayerRect bounds = Bounds();
- wr::WrMixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetLayer()->GetMixBlendMode());
+ wr::MixBlendMode mixBlendMode = wr::ToMixBlendMode(GetLayer()->GetMixBlendMode());
printf_stderr("%s %p using bounds=%s, transform=%s, rect=%s, clip=%s, mix-blend-mode=%s\n",
aLayerType,
layer,
Stringify(bounds).c_str(),
Stringify(transform).c_str(),
Stringify(aRect).c_str(),
layer->GetClipRect() ? Stringify(layer->GetClipRect().value()).c_str() : "none",
--- a/gfx/layers/wr/WebRenderMessageUtils.h
+++ b/gfx/layers/wr/WebRenderMessageUtils.h
@@ -101,21 +101,21 @@ struct ParamTraits<mozilla::wr::Pipeline
Read(const Message* aMsg, PickleIterator* aIter, mozilla::wr::PipelineId* aResult)
{
return ReadParam(aMsg, aIter, &aResult->mNamespace)
&& ReadParam(aMsg, aIter, &aResult->mHandle);
}
};
template<>
-struct ParamTraits<mozilla::wr::WrImageFormat>
+struct ParamTraits<mozilla::wr::ImageFormat>
: public ContiguousEnumSerializer<
- mozilla::wr::WrImageFormat,
- mozilla::wr::WrImageFormat::Invalid,
- mozilla::wr::WrImageFormat::Sentinel>
+ mozilla::wr::ImageFormat,
+ mozilla::wr::ImageFormat::Invalid,
+ mozilla::wr::ImageFormat::Sentinel>
{
};
template<>
struct ParamTraits<mozilla::wr::LayoutSize>
{
static void
Write(Message* aMsg, const mozilla::wr::LayoutSize& aParam)
@@ -188,45 +188,45 @@ struct ParamTraits<mozilla::wr::WrImageM
{
return ReadParam(aMsg, aIter, &aResult->image)
&& ReadParam(aMsg, aIter, &aResult->rect)
&& ReadParam(aMsg, aIter, &aResult->repeat);
}
};
template<>
-struct ParamTraits<mozilla::wr::WrImageRendering>
+struct ParamTraits<mozilla::wr::ImageRendering>
: public ContiguousEnumSerializer<
- mozilla::wr::WrImageRendering,
- mozilla::wr::WrImageRendering::Auto,
- mozilla::wr::WrImageRendering::Sentinel>
+ mozilla::wr::ImageRendering,
+ mozilla::wr::ImageRendering::Auto,
+ mozilla::wr::ImageRendering::Sentinel>
{
};
template<>
-struct ParamTraits<mozilla::wr::WrMixBlendMode>
+struct ParamTraits<mozilla::wr::MixBlendMode>
: public ContiguousEnumSerializer<
- mozilla::wr::WrMixBlendMode,
- mozilla::wr::WrMixBlendMode::Normal,
- mozilla::wr::WrMixBlendMode::Sentinel>
+ mozilla::wr::MixBlendMode,
+ mozilla::wr::MixBlendMode::Normal,
+ mozilla::wr::MixBlendMode::Sentinel>
{
};
template<>
-struct ParamTraits<mozilla::wr::WrBuiltDisplayListDescriptor>
+struct ParamTraits<mozilla::wr::BuiltDisplayListDescriptor>
{
static void
- Write(Message* aMsg, const mozilla::wr::WrBuiltDisplayListDescriptor& aParam)
+ Write(Message* aMsg, const mozilla::wr::BuiltDisplayListDescriptor& aParam)
{
WriteParam(aMsg, aParam.builder_start_time);
WriteParam(aMsg, aParam.builder_finish_time);
}
static bool
- Read(const Message* aMsg, PickleIterator* aIter, mozilla::wr::WrBuiltDisplayListDescriptor* aResult)
+ Read(const Message* aMsg, PickleIterator* aIter, mozilla::wr::BuiltDisplayListDescriptor* aResult)
{
return ReadParam(aMsg, aIter, &aResult->builder_start_time)
&& ReadParam(aMsg, aIter, &aResult->builder_finish_time);
}
};
} // namespace IPC
--- a/gfx/layers/wr/WebRenderUserData.cpp
+++ b/gfx/layers/wr/WebRenderUserData.cpp
@@ -88,18 +88,18 @@ WebRenderImageData::GetImageClient()
void
WebRenderImageData::CreateAsyncImageWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
ImageContainer* aContainer,
const StackingContextHelper& aSc,
const LayerRect& aBounds,
const LayerRect& aSCBounds,
const Matrix4x4& aSCTransform,
const MaybeIntSize& aScaleToSize,
- const wr::WrImageRendering& aFilter,
- const wr::WrMixBlendMode& aMixBlendMode)
+ const wr::ImageRendering& aFilter,
+ const wr::MixBlendMode& aMixBlendMode)
{
MOZ_ASSERT(aContainer->IsAsync());
if (!mPipelineId) {
// Alloc async image pipeline id.
mPipelineId = Some(WrBridge()->GetCompositorBridgeChild()->GetNextPipelineId());
WrBridge()->AddPipelineIdForAsyncCompositable(mPipelineId.ref(),
aContainer->GetAsyncContainerHandle());
}
--- a/gfx/layers/wr/WebRenderUserData.h
+++ b/gfx/layers/wr/WebRenderUserData.h
@@ -62,18 +62,18 @@ public:
void CreateAsyncImageWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
ImageContainer* aContainer,
const StackingContextHelper& aSc,
const LayerRect& aBounds,
const LayerRect& aSCBounds,
const gfx::Matrix4x4& aSCTransform,
const gfx::MaybeIntSize& aScaleToSize,
- const wr::WrImageRendering& aFilter,
- const wr::WrMixBlendMode& aMixBlendMode);
+ const wr::ImageRendering& aFilter,
+ const wr::MixBlendMode& aMixBlendMode);
void CreateImageClientIfNeeded();
protected:
void CreateExternalImageIfNeeded();
wr::MaybeExternalImageId mExternalImageId;
Maybe<wr::ImageKey> mKey;
--- a/gfx/webrender_bindings/Moz2DImageRenderer.cpp
+++ b/gfx/webrender_bindings/Moz2DImageRenderer.cpp
@@ -92,15 +92,15 @@ extern "C" {
bool wr_moz2d_render_cb(const mozilla::wr::ByteSlice blob,
uint32_t width, uint32_t height,
mozilla::wr::ImageFormat aFormat,
mozilla::wr::MutByteSlice output)
{
return mozilla::wr::Moz2DRenderCallback(mozilla::wr::ByteSliceToRange(blob),
mozilla::gfx::IntSize(width, height),
- mozilla::wr::WrImageFormatToSurfaceFormat(aFormat),
+ mozilla::wr::ImageFormatToSurfaceFormat(aFormat),
mozilla::wr::MutByteSliceToRange(output));
}
} // extern
--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -51,58 +51,58 @@ void UnlockExternalImage(void* aObj, wr:
MOZ_ASSERT(texture);
texture->Unlock();
}
RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
RefPtr<gl::GLContext>&& aGL,
RefPtr<widget::CompositorWidget>&& aWidget,
wr::WindowId aWindowId,
- wr::WrRenderer* aWrRenderer,
+ wr::Renderer* aRenderer,
layers::CompositorBridgeParentBase* aBridge)
: mThread(aThread)
, mGL(aGL)
, mWidget(aWidget)
- , mWrRenderer(aWrRenderer)
+ , mRenderer(aRenderer)
, mBridge(aBridge)
, mWindowId(aWindowId)
{
MOZ_ASSERT(mThread);
MOZ_ASSERT(mGL);
MOZ_ASSERT(mWidget);
- MOZ_ASSERT(mWrRenderer);
+ MOZ_ASSERT(mRenderer);
MOZ_ASSERT(mBridge);
MOZ_COUNT_CTOR(RendererOGL);
}
RendererOGL::~RendererOGL()
{
MOZ_COUNT_DTOR(RendererOGL);
if (!mGL->MakeCurrent()) {
gfxCriticalNote << "Failed to make render context current during destroying.";
// Leak resources!
return;
}
- wr_renderer_delete(mWrRenderer);
+ wr_renderer_delete(mRenderer);
}
wr::WrExternalImageHandler
RendererOGL::GetExternalImageHandler()
{
return wr::WrExternalImageHandler {
this,
LockExternalImage,
UnlockExternalImage,
};
}
void
RendererOGL::Update()
{
- wr_renderer_update(mWrRenderer);
+ wr_renderer_update(mRenderer);
}
bool
RendererOGL::Render()
{
if (!mGL->MakeCurrent()) {
gfxCriticalNote << "Failed to make render context current, can't draw.";
// XXX This could cause oom in webrender since pending_texture_updates is not handled.
@@ -122,17 +122,17 @@ RendererOGL::Render()
if (!mWidget->PreRender(&widgetContext)) {
// XXX This could cause oom in webrender since pending_texture_updates is not handled.
// It needs to be addressed.
return false;
}
// XXX set clear color if MOZ_WIDGET_ANDROID is defined.
auto size = mWidget->GetClientSize();
- wr_renderer_render(mWrRenderer, size.width, size.height);
+ wr_renderer_render(mRenderer, size.width, size.height);
mGL->SwapBuffers();
mWidget->PostRender(&widgetContext);
// TODO: Flush pending actions such as texture deletions/unlocks and
// textureHosts recycling.
return true;
@@ -162,23 +162,23 @@ RendererOGL::Resume()
#else
return true;
#endif
}
void
RendererOGL::SetProfilerEnabled(bool aEnabled)
{
- wr_renderer_set_profiler_enabled(mWrRenderer, aEnabled);
+ wr_renderer_set_profiler_enabled(mRenderer, aEnabled);
}
wr::WrRenderedEpochs*
RendererOGL::FlushRenderedEpochs()
{
- return wr_renderer_flush_rendered_epochs(mWrRenderer);
+ return wr_renderer_flush_rendered_epochs(mRenderer);
}
RenderTextureHost*
RendererOGL::GetRenderTexture(wr::WrExternalImageId aExternalImageId)
{
return mThread->GetRenderTexture(aExternalImageId);
}
--- a/gfx/webrender_bindings/RendererOGL.h
+++ b/gfx/webrender_bindings/RendererOGL.h
@@ -61,39 +61,39 @@ public:
/// This can be called on the render thread only.
~RendererOGL();
/// This can be called on the render thread only.
RendererOGL(RefPtr<RenderThread>&& aThread,
RefPtr<gl::GLContext>&& aGL,
RefPtr<widget::CompositorWidget>&&,
wr::WindowId aWindowId,
- wr::WrRenderer* aWrRenderer,
+ wr::Renderer* aRenderer,
layers::CompositorBridgeParentBase* aBridge);
/// This can be called on the render thread only.
void Pause();
/// This can be called on the render thread only.
bool Resume();
layers::CompositorBridgeParentBase* GetCompositorBridge() { return mBridge; }
wr::WrRenderedEpochs* FlushRenderedEpochs();
RenderTextureHost* GetRenderTexture(wr::WrExternalImageId aExternalImageId);
- wr::WrRenderer* GetWrRenderer() { return mWrRenderer; }
+ wr::Renderer* GetRenderer() { return mRenderer; }
protected:
RefPtr<RenderThread> mThread;
RefPtr<gl::GLContext> mGL;
RefPtr<widget::CompositorWidget> mWidget;
- wr::WrRenderer* mWrRenderer;
+ wr::Renderer* mRenderer;
layers::CompositorBridgeParentBase* mBridge;
wr::WindowId mWindowId;
};
} // namespace wr
} // namespace mozilla
#endif
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -18,24 +18,24 @@
namespace mozilla {
namespace wr {
using layers::Stringify;
class NewRenderer : public RendererEvent
{
public:
- NewRenderer(wr::WrAPI** aApi, layers::CompositorBridgeParentBase* aBridge,
+ NewRenderer(wr::RenderApi** aApi, layers::CompositorBridgeParentBase* aBridge,
GLint* aMaxTextureSize,
bool* aUseANGLE,
RefPtr<widget::CompositorWidget>&& aWidget,
layers::SynchronousTask* aTask,
bool aEnableProfiler,
LayoutDeviceIntSize aSize)
- : mWrApi(aApi)
+ : mRenderApi(aApi)
, mMaxTextureSize(aMaxTextureSize)
, mUseANGLE(aUseANGLE)
, mBridge(aBridge)
, mCompositorWidget(Move(aWidget))
, mTask(aTask)
, mEnableProfiler(aEnableProfiler)
, mSize(aSize)
{
@@ -65,20 +65,20 @@ public:
if (!gl || !gl->MakeCurrent()) {
gfxCriticalNote << "Failed GL context creation for WebRender: " << gfx::hexa(gl.get());
return;
}
gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, mMaxTextureSize);
*mUseANGLE = gl->IsANGLE();
- wr::WrRenderer* wrRenderer = nullptr;
+ wr::Renderer* wrRenderer = nullptr;
if (!wr_window_new(aWindowId, mSize.width, mSize.height, gl.get(),
aRenderThread.ThreadPool().Raw(),
- this->mEnableProfiler, mWrApi, &wrRenderer)) {
+ this->mEnableProfiler, mRenderApi, &wrRenderer)) {
// wr_window_new puts a message into gfxCriticalNote if it returns false
return;
}
MOZ_ASSERT(wrRenderer);
RefPtr<RenderThread> thread = &aRenderThread;
auto renderer = MakeUnique<RendererOGL>(Move(thread),
Move(gl),
@@ -90,17 +90,17 @@ public:
wr::WrExternalImageHandler handler = renderer->GetExternalImageHandler();
wr_renderer_set_external_image_handler(wrRenderer, &handler);
}
aRenderThread.AddRenderer(aWindowId, Move(renderer));
}
private:
- wr::WrAPI** mWrApi;
+ wr::RenderApi** mRenderApi;
GLint* mMaxTextureSize;
bool* mUseANGLE;
layers::CompositorBridgeParentBase* mBridge;
RefPtr<widget::CompositorWidget> mCompositorWidget;
layers::SynchronousTask* mTask;
bool mEnableProfiler;
LayoutDeviceIntSize mSize;
};
@@ -138,111 +138,111 @@ WebRenderAPI::Create(bool aEnableProfile
LayoutDeviceIntSize aSize)
{
MOZ_ASSERT(aBridge);
MOZ_ASSERT(aWidget);
static uint64_t sNextId = 1;
auto id = NewWindowId(sNextId++);
- wr::WrAPI* wrApi = nullptr;
+ wr::RenderApi* renderApi = nullptr;
GLint maxTextureSize = 0;
bool useANGLE = false;
- // Dispatch a synchronous task because the WrApi object needs to be created
+ // Dispatch a synchronous task because the RenderApi object needs to be created
// on the render thread. If need be we could delay waiting on this task until
- // the next time we need to access the WrApi object.
+ // the next time we need to access the RenderApi object.
layers::SynchronousTask task("Create Renderer");
- auto event = MakeUnique<NewRenderer>(&wrApi, aBridge, &maxTextureSize, &useANGLE,
+ auto event = MakeUnique<NewRenderer>(&renderApi, aBridge, &maxTextureSize, &useANGLE,
Move(aWidget), &task, aEnableProfiler, aSize);
RenderThread::Get()->RunEvent(id, Move(event));
task.Wait();
- if (!wrApi) {
+ if (!renderApi) {
return nullptr;
}
- return RefPtr<WebRenderAPI>(new WebRenderAPI(wrApi, id, maxTextureSize, useANGLE)).forget();
+ return RefPtr<WebRenderAPI>(new WebRenderAPI(renderApi, id, maxTextureSize, useANGLE)).forget();
}
wr::WrIdNamespace
WebRenderAPI::GetNamespace() {
- return wr_api_get_namespace(mWrApi);
+ return wr_api_get_namespace(mRenderApi);
}
WebRenderAPI::~WebRenderAPI()
{
layers::SynchronousTask task("Destroy WebRenderAPI");
auto event = MakeUnique<RemoveRenderer>(&task);
RunOnRenderThread(Move(event));
task.Wait();
- wr_api_delete(mWrApi);
+ wr_api_delete(mRenderApi);
}
void
WebRenderAPI::UpdateScrollPosition(const wr::WrPipelineId& aPipelineId,
const layers::FrameMetrics::ViewID& aScrollId,
const wr::LayoutPoint& aScrollPosition)
{
- wr_scroll_layer_with_id(mWrApi, aPipelineId, aScrollId, aScrollPosition);
+ wr_scroll_layer_with_id(mRenderApi, aPipelineId, aScrollId, aScrollPosition);
}
void
WebRenderAPI::GenerateFrame()
{
- wr_api_generate_frame(mWrApi);
+ wr_api_generate_frame(mRenderApi);
}
void
WebRenderAPI::GenerateFrame(const nsTArray<wr::WrOpacityProperty>& aOpacityArray,
const nsTArray<wr::WrTransformProperty>& aTransformArray)
{
- wr_api_generate_frame_with_properties(mWrApi,
+ wr_api_generate_frame_with_properties(mRenderApi,
aOpacityArray.IsEmpty() ?
nullptr : aOpacityArray.Elements(),
aOpacityArray.Length(),
aTransformArray.IsEmpty() ?
nullptr : aTransformArray.Elements(),
aTransformArray.Length());
}
void
WebRenderAPI::SetRootDisplayList(gfx::Color aBgColor,
Epoch aEpoch,
LayerSize aViewportSize,
wr::WrPipelineId pipeline_id,
const LayoutSize& content_size,
- wr::WrBuiltDisplayListDescriptor dl_descriptor,
+ wr::BuiltDisplayListDescriptor dl_descriptor,
uint8_t *dl_data,
size_t dl_size)
{
- wr_api_set_root_display_list(mWrApi,
+ wr_api_set_root_display_list(mRenderApi,
ToColorF(aBgColor),
aEpoch,
aViewportSize.width, aViewportSize.height,
pipeline_id,
content_size,
dl_descriptor,
dl_data,
dl_size);
}
void
WebRenderAPI::ClearRootDisplayList(Epoch aEpoch,
wr::WrPipelineId pipeline_id)
{
- wr_api_clear_root_display_list(mWrApi, aEpoch, pipeline_id);
+ wr_api_clear_root_display_list(mRenderApi, aEpoch, pipeline_id);
}
void
WebRenderAPI::SetWindowParameters(LayoutDeviceIntSize size)
{
- wr_api_set_window_parameters(mWrApi, size.width, size.height);
+ wr_api_set_window_parameters(mRenderApi, size.width, size.height);
}
void
WebRenderAPI::Readback(gfx::IntSize size,
uint8_t *buffer,
uint32_t buffer_size)
{
class Readback : public RendererEvent
@@ -261,17 +261,17 @@ WebRenderAPI::Readback(gfx::IntSize size
~Readback()
{
MOZ_COUNT_DTOR(Readback);
}
virtual void Run(RenderThread& aRenderThread, WindowId aWindowId) override
{
aRenderThread.UpdateAndRender(aWindowId);
- wr_renderer_readback(aRenderThread.GetRenderer(aWindowId)->GetWrRenderer(),
+ wr_renderer_readback(aRenderThread.GetRenderer(aWindowId)->GetRenderer(),
mSize.width, mSize.height, mBuffer, mBufferSize);
layers::AutoCompleteTask complete(mTask);
}
layers::SynchronousTask* mTask;
gfx::IntSize mSize;
uint8_t *mBuffer;
uint32_t mBufferSize;
@@ -394,92 +394,92 @@ WebRenderAPI::WaitFlushed()
RunOnRenderThread(Move(event));
task.Wait();
}
void
WebRenderAPI::SetRootPipeline(PipelineId aPipeline)
{
- wr_api_set_root_pipeline(mWrApi, aPipeline);
+ wr_api_set_root_pipeline(mRenderApi, aPipeline);
}
void
WebRenderAPI::AddImage(ImageKey key, const ImageDescriptor& aDescriptor,
Range<uint8_t> aBytes)
{
- wr_api_add_image(mWrApi,
+ wr_api_add_image(mRenderApi,
key,
&aDescriptor,
RangeToByteSlice(aBytes));
}
void
WebRenderAPI::AddBlobImage(ImageKey key, const ImageDescriptor& aDescriptor,
Range<uint8_t> aBytes)
{
- wr_api_add_blob_image(mWrApi,
+ wr_api_add_blob_image(mRenderApi,
key,
&aDescriptor,
RangeToByteSlice(aBytes));
}
void
WebRenderAPI::AddExternalImage(ImageKey key,
const ImageDescriptor& aDescriptor,
ExternalImageId aExtID,
wr::WrExternalImageBufferType aBufferType,
uint8_t aChannelIndex)
{
- wr_api_add_external_image(mWrApi,
+ wr_api_add_external_image(mRenderApi,
key,
&aDescriptor,
aExtID,
aBufferType,
aChannelIndex);
}
void
WebRenderAPI::AddExternalImageBuffer(ImageKey key,
const ImageDescriptor& aDescriptor,
ExternalImageId aHandle)
{
- wr_api_add_external_image_buffer(mWrApi,
+ wr_api_add_external_image_buffer(mRenderApi,
key,
&aDescriptor,
aHandle);
}
void
WebRenderAPI::UpdateImageBuffer(ImageKey aKey,
const ImageDescriptor& aDescriptor,
Range<uint8_t> aBytes)
{
- wr_api_update_image(mWrApi,
+ wr_api_update_image(mRenderApi,
aKey,
&aDescriptor,
RangeToByteSlice(aBytes));
}
void
WebRenderAPI::DeleteImage(ImageKey aKey)
{
- wr_api_delete_image(mWrApi, aKey);
+ wr_api_delete_image(mRenderApi, aKey);
}
void
WebRenderAPI::AddRawFont(wr::FontKey aKey, Range<uint8_t> aBytes, uint32_t aIndex)
{
- wr_api_add_raw_font(mWrApi, aKey, &aBytes[0], aBytes.length(), aIndex);
+ wr_api_add_raw_font(mRenderApi, aKey, &aBytes[0], aBytes.length(), aIndex);
}
void
WebRenderAPI::DeleteFont(wr::FontKey aKey)
{
- wr_api_delete_font(mWrApi, aKey);
+ wr_api_delete_font(mRenderApi, aKey);
}
class EnableProfiler : public RendererEvent
{
public:
explicit EnableProfiler(bool aEnabled)
: mEnabled(aEnabled)
{
@@ -509,17 +509,17 @@ WebRenderAPI::SetProfilerEnabled(bool aE
auto event = MakeUnique<EnableProfiler>(aEnabled);
RunOnRenderThread(Move(event));
}
void
WebRenderAPI::RunOnRenderThread(UniquePtr<RendererEvent> aEvent)
{
auto event = reinterpret_cast<uintptr_t>(aEvent.release());
- wr_api_send_external_event(mWrApi, event);
+ wr_api_send_external_event(mRenderApi, event);
}
DisplayListBuilder::DisplayListBuilder(PipelineId aId,
const wr::LayoutSize& aContentSize)
{
MOZ_COUNT_CTOR(DisplayListBuilder);
mWrState = wr_state_new(aId, aContentSize);
}
@@ -552,18 +552,18 @@ DisplayListBuilder::Finalize(wr::LayoutS
&aOutDisplayList.dl.inner);
}
void
DisplayListBuilder::PushStackingContext(const wr::LayoutRect& aBounds,
const uint64_t& aAnimationId,
const float* aOpacity,
const gfx::Matrix4x4* aTransform,
- wr::WrTransformStyle aTransformStyle,
- const wr::WrMixBlendMode& aMixBlendMode,
+ wr::TransformStyle aTransformStyle,
+ const wr::MixBlendMode& aMixBlendMode,
const nsTArray<wr::WrFilterOp>& aFilters)
{
wr::LayoutTransform matrix;
if (aTransform) {
matrix = ToLayoutTransform(*aTransform);
}
const wr::LayoutTransform* maybeTransform = aTransform ? &matrix : nullptr;
WRDL_LOG("PushStackingContext b=%s t=%s\n", Stringify(aBounds).c_str(),
@@ -863,17 +863,17 @@ void
DisplayListBuilder::PushBoxShadow(const wr::LayoutRect& aRect,
const wr::LayoutRect& aClip,
const wr::LayoutRect& aBoxBounds,
const wr::LayoutVector2D& aOffset,
const wr::ColorF& aColor,
const float& aBlurRadius,
const float& aSpreadRadius,
const float& aBorderRadius,
- const wr::WrBoxShadowClipMode& aClipMode)
+ const wr::BoxShadowClipMode& aClipMode)
{
wr_dp_push_box_shadow(mWrState, aRect, aClip,
aBoxBounds, aOffset, aColor,
aBlurRadius, aSpreadRadius, aBorderRadius,
aClipMode);
}
Maybe<wr::WrClipId>
--- a/gfx/webrender_bindings/WebRenderAPI.h
+++ b/gfx/webrender_bindings/WebRenderAPI.h
@@ -57,17 +57,17 @@ public:
const nsTArray<wr::WrTransformProperty>& aTransformArray);
void SetWindowParameters(LayoutDeviceIntSize size);
void SetRootDisplayList(gfx::Color aBgColor,
Epoch aEpoch,
LayerSize aViewportSize,
wr::WrPipelineId pipeline_id,
const wr::LayoutSize& content_size,
- wr::WrBuiltDisplayListDescriptor dl_descriptor,
+ wr::BuiltDisplayListDescriptor dl_descriptor,
uint8_t *dl_data,
size_t dl_size);
void ClearRootDisplayList(Epoch aEpoch,
wr::WrPipelineId pipeline_id);
void SetRootPipeline(wr::PipelineId aPipeline);
@@ -107,28 +107,28 @@ public:
void Pause();
bool Resume();
wr::WrIdNamespace GetNamespace();
GLint GetMaxTextureSize() const { return mMaxTextureSize; }
bool GetUseANGLE() const { return mUseANGLE; }
protected:
- WebRenderAPI(wr::WrAPI* aRawApi, wr::WindowId aId, GLint aMaxTextureSize, bool aUseANGLE)
- : mWrApi(aRawApi)
+ WebRenderAPI(wr::RenderApi* aRawApi, wr::WindowId aId, GLint aMaxTextureSize, bool aUseANGLE)
+ : mRenderApi(aRawApi)
, mId(aId)
, mMaxTextureSize(aMaxTextureSize)
, mUseANGLE(aUseANGLE)
{}
~WebRenderAPI();
// Should be used only for shutdown handling
void WaitFlushed();
- wr::WrAPI* mWrApi;
+ wr::RenderApi* mRenderApi;
wr::WindowId mId;
GLint mMaxTextureSize;
bool mUseANGLE;
friend class DisplayListBuilder;
friend class layers::WebRenderBridgeParent;
};
@@ -148,18 +148,18 @@ public:
void End();
void Finalize(wr::LayoutSize& aOutContentSize,
wr::BuiltDisplayList& aOutDisplayList);
void PushStackingContext(const wr::LayoutRect& aBounds, // TODO: We should work with strongly typed rects
const uint64_t& aAnimationId,
const float* aOpacity,
const gfx::Matrix4x4* aTransform,
- wr::WrTransformStyle aTransformStyle,
- const wr::WrMixBlendMode& aMixBlendMode,
+ wr::TransformStyle aTransformStyle,
+ const wr::MixBlendMode& aMixBlendMode,
const nsTArray<wr::WrFilterOp>& aFilters);
void PopStackingContext();
void PushClip(const wr::LayoutRect& aClipRect,
const wr::WrImageMask* aMask);
void PopClip();
void PushBuiltDisplayList(wr::BuiltDisplayList &dl);
@@ -276,17 +276,17 @@ public:
void PushBoxShadow(const wr::LayoutRect& aRect,
const wr::LayoutRect& aClip,
const wr::LayoutRect& aBoxBounds,
const wr::LayoutVector2D& aOffset,
const wr::ColorF& aColor,
const float& aBlurRadius,
const float& aSpreadRadius,
const float& aBorderRadius,
- const wr::WrBoxShadowClipMode& aClipMode);
+ const wr::BoxShadowClipMode& aClipMode);
// Returns the clip id that was most recently pushed with PushClip and that
// has not yet been popped with PopClip. Return Nothing() if the clip stack
// is empty.
Maybe<wr::WrClipId> TopmostClipId();
// Returns the scroll id that was pushed just before the given scroll id. This
// function returns Nothing() if the given scrollid has not been encountered,
// or if it is the rootmost scroll id (and therefore has no ancestor).
@@ -305,15 +305,15 @@ protected:
std::vector<layers::FrameMetrics::ViewID> mScrollIdStack;
// Track the parent scroll id of each scroll id that we encountered.
std::unordered_map<layers::FrameMetrics::ViewID, layers::FrameMetrics::ViewID> mScrollParents;
friend class WebRenderAPI;
};
-Maybe<wr::WrImageFormat>
-SurfaceFormatToWrImageFormat(gfx::SurfaceFormat aFormat);
+Maybe<wr::ImageFormat>
+SurfaceFormatToImageFormat(gfx::SurfaceFormat aFormat);
} // namespace wr
} // namespace mozilla
#endif
--- a/gfx/webrender_bindings/WebRenderTypes.h
+++ b/gfx/webrender_bindings/WebRenderTypes.h
@@ -15,19 +15,16 @@
#include "mozilla/Range.h"
#include "Units.h"
#include "RoundedRect.h"
#include "nsStyleConsts.h"
namespace mozilla {
namespace wr {
-typedef wr::WrMixBlendMode MixBlendMode;
-typedef wr::WrImageRendering ImageRendering;
-typedef wr::WrImageFormat ImageFormat;
typedef wr::WrWindowId WindowId;
typedef wr::WrPipelineId PipelineId;
typedef wr::WrImageKey ImageKey;
typedef wr::WrFontKey FontKey;
typedef wr::WrEpoch Epoch;
typedef wr::WrExternalImageId ExternalImageId;
typedef mozilla::Maybe<mozilla::wr::WrImageMask> MaybeImageMask;
@@ -40,67 +37,67 @@ inline WindowId NewWindowId(uint64_t aId
}
inline Epoch NewEpoch(uint32_t aEpoch) {
Epoch e;
e.mHandle = aEpoch;
return e;
}
-inline Maybe<wr::WrImageFormat>
-SurfaceFormatToWrImageFormat(gfx::SurfaceFormat aFormat) {
+inline Maybe<wr::ImageFormat>
+SurfaceFormatToImageFormat(gfx::SurfaceFormat aFormat) {
switch (aFormat) {
case gfx::SurfaceFormat::R8G8B8X8:
// TODO: use RGBA + opaque flag
- return Some(wr::WrImageFormat::BGRA8);
+ return Some(wr::ImageFormat::BGRA8);
case gfx::SurfaceFormat::B8G8R8X8:
// TODO: WebRender will have a BGRA + opaque flag for this but does not
// have it yet (cf. issue #732).
case gfx::SurfaceFormat::B8G8R8A8:
- return Some(wr::WrImageFormat::BGRA8);
+ return Some(wr::ImageFormat::BGRA8);
case gfx::SurfaceFormat::B8G8R8:
- return Some(wr::WrImageFormat::RGB8);
+ return Some(wr::ImageFormat::RGB8);
case gfx::SurfaceFormat::A8:
- return Some(wr::WrImageFormat::A8);
+ return Some(wr::ImageFormat::A8);
case gfx::SurfaceFormat::R8G8:
- return Some(wr::WrImageFormat::RG8);
+ return Some(wr::ImageFormat::RG8);
case gfx::SurfaceFormat::UNKNOWN:
- return Some(wr::WrImageFormat::Invalid);
+ return Some(wr::ImageFormat::Invalid);
default:
return Nothing();
}
}
inline gfx::SurfaceFormat
-WrImageFormatToSurfaceFormat(ImageFormat aFormat) {
+ImageFormatToSurfaceFormat(ImageFormat aFormat) {
switch (aFormat) {
case ImageFormat::BGRA8:
return gfx::SurfaceFormat::B8G8R8A8;
case ImageFormat::A8:
return gfx::SurfaceFormat::A8;
case ImageFormat::RGB8:
return gfx::SurfaceFormat::B8G8R8;
default:
return gfx::SurfaceFormat::UNKNOWN;
}
}
struct ImageDescriptor: public wr::WrImageDescriptor {
ImageDescriptor(const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat)
{
- format = SurfaceFormatToWrImageFormat(aFormat).value();
+ format = wr::SurfaceFormatToImageFormat(aFormat).value();
width = aSize.width;
height = aSize.height;
stride = 0;
is_opaque = gfx::IsOpaqueFormat(aFormat);
}
ImageDescriptor(const gfx::IntSize& aSize, uint32_t aByteStride, gfx::SurfaceFormat aFormat)
{
- format = SurfaceFormatToWrImageFormat(aFormat).value();
+ format = wr::SurfaceFormatToImageFormat(aFormat).value();
width = aSize.width;
height = aSize.height;
stride = aByteStride;
is_opaque = gfx::IsOpaqueFormat(aFormat);
}
};
// Whenever possible, use wr::WindowId instead of manipulating uint64_t.
@@ -148,17 +145,17 @@ inline PipelineId AsPipelineId(const uin
}
inline ImageRendering ToImageRendering(gfx::SamplingFilter aFilter)
{
return aFilter == gfx::SamplingFilter::POINT ? ImageRendering::Pixelated
: ImageRendering::Auto;
}
-static inline MixBlendMode ToWrMixBlendMode(gfx::CompositionOp compositionOp)
+static inline MixBlendMode ToMixBlendMode(gfx::CompositionOp compositionOp)
{
switch (compositionOp)
{
case gfx::CompositionOp::OP_MULTIPLY:
return MixBlendMode::Multiply;
case gfx::CompositionOp::OP_SCREEN:
return MixBlendMode::Screen;
case gfx::CompositionOp::OP_OVERLAY:
@@ -620,17 +617,17 @@ inline mozilla::Range<const uint8_t> Byt
}
inline mozilla::Range<uint8_t> MutByteSliceToRange(wr::MutByteSlice aWrSlice) {
return mozilla::Range<uint8_t>(aWrSlice.buffer, aWrSlice.len);
}
struct BuiltDisplayList {
wr::VecU8 dl;
- wr::WrBuiltDisplayListDescriptor dl_desc;
+ wr::BuiltDisplayListDescriptor dl_desc;
};
static inline wr::WrFilterOpType ToWrFilterOpType(const layers::CSSFilterType type) {
switch (type) {
case layers::CSSFilterType::BLUR:
return wr::WrFilterOpType::Blur;
case layers::CSSFilterType::BRIGHTNESS:
return wr::WrFilterOpType::Brightness;
--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -13,25 +13,16 @@ use webrender::{ApiRecordingReceiver, Bi
use thread_profiler::register_thread_with_profiler;
use moz2d_renderer::Moz2dImageRenderer;
use app_units::Au;
use rayon;
use euclid::SideOffsets2D;
extern crate webrender_api;
-type WrAPI = RenderApi;
-type WrBoxShadowClipMode = BoxShadowClipMode;
-type WrBuiltDisplayListDescriptor = BuiltDisplayListDescriptor;
-type WrImageFormat = ImageFormat;
-type WrImageRendering = ImageRendering;
-type WrMixBlendMode = MixBlendMode;
-type WrTransformStyle = TransformStyle;
-type WrRenderer = Renderer;
-
/// cbindgen:field-names=[mNamespace, mHandle]
type WrExternalImageBufferType = ExternalImageType;
/// cbindgen:field-names=[mHandle]
/// cbindgen:derive-lt=true
/// cbindgen:derive-lte=true
type WrEpoch = Epoch;
/// cbindgen:field-names=[mHandle]
@@ -164,17 +155,17 @@ impl From<ImageMask> for WrImageMask {
repeat: image_mask.repeat,
}
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WrImageDescriptor {
- pub format: WrImageFormat,
+ pub format: ImageFormat,
pub width: u32,
pub height: u32,
pub stride: u32,
pub is_opaque: bool,
}
impl<'a> Into<ImageDescriptor> for &'a WrImageDescriptor {
fn into(self) -> ImageDescriptor {
@@ -406,89 +397,89 @@ impl webrender_api::RenderNotifier for C
event: ExternalEvent) {
unsafe {
wr_notifier_external_event(self.window_id, event.unwrap());
}
}
}
#[no_mangle]
-pub extern "C" fn wr_renderer_set_external_image_handler(renderer: &mut WrRenderer,
+pub extern "C" fn wr_renderer_set_external_image_handler(renderer: &mut Renderer,
external_image_handler: *mut WrExternalImageHandler) {
if !external_image_handler.is_null() {
renderer.set_external_image_handler(Box::new(unsafe {
WrExternalImageHandler {
external_image_obj:
(*external_image_handler).external_image_obj,
lock_func: (*external_image_handler).lock_func,
unlock_func: (*external_image_handler).unlock_func,
}
}));
}
}
#[no_mangle]
-pub extern "C" fn wr_renderer_update(renderer: &mut WrRenderer) {
+pub extern "C" fn wr_renderer_update(renderer: &mut Renderer) {
renderer.update();
}
#[no_mangle]
-pub extern "C" fn wr_renderer_render(renderer: &mut WrRenderer,
+pub extern "C" fn wr_renderer_render(renderer: &mut Renderer,
width: u32,
height: u32) {
renderer.render(DeviceUintSize::new(width, height));
}
// Call wr_renderer_render() before calling this function.
#[no_mangle]
-pub unsafe extern "C" fn wr_renderer_readback(renderer: &mut WrRenderer,
+pub unsafe extern "C" fn wr_renderer_readback(renderer: &mut Renderer,
width: u32,
height: u32,
dst_buffer: *mut u8,
buffer_size: usize) {
assert!(is_in_render_thread());
let mut slice = make_slice_mut(dst_buffer, buffer_size);
renderer.read_pixels_into(DeviceUintRect::new(
DeviceUintPoint::new(0, 0),
DeviceUintSize::new(width, height)),
ReadPixelsFormat::Bgra8,
&mut slice);
}
#[no_mangle]
-pub extern "C" fn wr_renderer_set_profiler_enabled(renderer: &mut WrRenderer,
+pub extern "C" fn wr_renderer_set_profiler_enabled(renderer: &mut Renderer,
enabled: bool) {
renderer.set_profiler_enabled(enabled);
}
#[no_mangle]
-pub extern "C" fn wr_renderer_current_epoch(renderer: &mut WrRenderer,
+pub extern "C" fn wr_renderer_current_epoch(renderer: &mut Renderer,
pipeline_id: WrPipelineId,
out_epoch: &mut WrEpoch)
-> bool {
if let Some(epoch) = renderer.current_epoch(pipeline_id) {
*out_epoch = epoch;
return true;
}
return false;
}
/// cbindgen:postfix=WR_DESTRUCTOR_SAFE_FUNC
#[no_mangle]
-pub unsafe extern "C" fn wr_renderer_delete(renderer: *mut WrRenderer) {
+pub unsafe extern "C" fn wr_renderer_delete(renderer: *mut Renderer) {
Box::from_raw(renderer);
}
pub struct WrRenderedEpochs {
data: Vec<(WrPipelineId, WrEpoch)>,
}
#[no_mangle]
-pub unsafe extern "C" fn wr_renderer_flush_rendered_epochs(renderer: &mut WrRenderer) -> *mut WrRenderedEpochs {
+pub unsafe extern "C" fn wr_renderer_flush_rendered_epochs(renderer: &mut Renderer) -> *mut WrRenderedEpochs {
let map = renderer.flush_rendered_epochs();
let pipeline_epochs = Box::new(WrRenderedEpochs {
data: map.into_iter().collect(),
});
return Box::into_raw(pipeline_epochs);
}
#[no_mangle]
@@ -534,18 +525,18 @@ pub unsafe extern "C" fn wr_thread_pool_
// Call MakeCurrent before this.
#[no_mangle]
pub extern "C" fn wr_window_new(window_id: WrWindowId,
window_width: u32,
window_height: u32,
gl_context: *mut c_void,
thread_pool: *mut WrThreadPool,
enable_profiler: bool,
- out_api: &mut *mut WrAPI,
- out_renderer: &mut *mut WrRenderer)
+ out_api: &mut *mut RenderApi,
+ out_renderer: &mut *mut Renderer)
-> bool {
assert!(unsafe { is_in_render_thread() });
let recorder: Option<Box<ApiRecordingReceiver>> = if unsafe { gfx_use_wrench() } {
let name = format!("wr-record-{}.bin", window_id.0);
Some(Box::new(BinaryRecorder::new(&PathBuf::from(name))))
} else {
None
@@ -574,20 +565,20 @@ pub extern "C" fn wr_window_new(window_i
recorder: recorder,
blob_image_renderer: Some(Box::new(Moz2dImageRenderer::new(workers.clone()))),
workers: Some(workers.clone()),
cache_expiry_frames: 60, // see https://github.com/servo/webrender/pull/1294#issuecomment-304318800
..Default::default()
};
let window_size = DeviceUintSize::new(window_width, window_height);
- let (renderer, sender) = match WrRenderer::new(gl, opts, window_size) {
+ let (renderer, sender) = match Renderer::new(gl, opts, window_size) {
Ok((renderer, sender)) => (renderer, sender),
Err(e) => {
- println!(" Failed to create a WrRenderer: {:?}", e);
+ println!(" Failed to create a Renderer: {:?}", e);
let msg = CString::new(format!("wr_window_new: {:?}", e)).unwrap();
unsafe {
gfx_critical_note(msg.as_ptr());
}
return false;
},
};
@@ -598,49 +589,49 @@ pub extern "C" fn wr_window_new(window_i
*out_api = Box::into_raw(Box::new(sender.create_api()));
*out_renderer = Box::into_raw(Box::new(renderer));
return true;
}
/// cbindgen:postfix=WR_DESTRUCTOR_SAFE_FUNC
#[no_mangle]
-pub unsafe extern "C" fn wr_api_delete(api: *mut WrAPI) {
+pub unsafe extern "C" fn wr_api_delete(api: *mut RenderApi) {
let api = Box::from_raw(api);
api.shut_down();
}
#[no_mangle]
-pub extern "C" fn wr_api_add_image(api: &mut WrAPI,
+pub extern "C" fn wr_api_add_image(api: &mut RenderApi,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
bytes: ByteSlice) {
assert!(unsafe { is_in_compositor_thread() });
let copied_bytes = bytes.as_slice().to_owned();
api.add_image(image_key,
descriptor.into(),
ImageData::new(copied_bytes),
None);
}
#[no_mangle]
-pub extern "C" fn wr_api_add_blob_image(api: &mut WrAPI,
+pub extern "C" fn wr_api_add_blob_image(api: &mut RenderApi,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
bytes: ByteSlice) {
assert!(unsafe { is_in_compositor_thread() });
let copied_bytes = bytes.as_slice().to_owned();
api.add_image(image_key,
descriptor.into(),
ImageData::new_blob_image(copied_bytes),
None);
}
#[no_mangle]
-pub extern "C" fn wr_api_add_external_image(api: &mut WrAPI,
+pub extern "C" fn wr_api_add_external_image(api: &mut RenderApi,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
external_image_id: WrExternalImageId,
buffer_type: WrExternalImageBufferType,
channel_index: u8) {
assert!(unsafe { is_in_compositor_thread() });
api.add_image(image_key,
descriptor.into(),
@@ -648,73 +639,73 @@ pub extern "C" fn wr_api_add_external_im
id: external_image_id.into(),
channel_index: channel_index,
image_type: buffer_type,
}),
None);
}
#[no_mangle]
-pub extern "C" fn wr_api_add_external_image_buffer(api: &mut WrAPI,
+pub extern "C" fn wr_api_add_external_image_buffer(api: &mut RenderApi,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
external_image_id: WrExternalImageId) {
assert!(unsafe { is_in_compositor_thread() });
api.add_image(image_key,
descriptor.into(),
ImageData::External(ExternalImageData {
id: external_image_id.into(),
channel_index: 0,
image_type: ExternalImageType::ExternalBuffer,
}),
None);
}
#[no_mangle]
-pub extern "C" fn wr_api_update_image(api: &mut WrAPI,
+pub extern "C" fn wr_api_update_image(api: &mut RenderApi,
key: WrImageKey,
descriptor: &WrImageDescriptor,
bytes: ByteSlice) {
assert!(unsafe { is_in_compositor_thread() });
let copied_bytes = bytes.as_slice().to_owned();
api.update_image(key, descriptor.into(), ImageData::new(copied_bytes), None);
}
#[no_mangle]
-pub extern "C" fn wr_api_delete_image(api: &mut WrAPI,
+pub extern "C" fn wr_api_delete_image(api: &mut RenderApi,
key: WrImageKey) {
assert!(unsafe { is_in_compositor_thread() });
api.delete_image(key)
}
#[no_mangle]
-pub extern "C" fn wr_api_set_root_pipeline(api: &mut WrAPI,
+pub extern "C" fn wr_api_set_root_pipeline(api: &mut RenderApi,
pipeline_id: WrPipelineId) {
api.set_root_pipeline(pipeline_id);
api.generate_frame(None);
}
#[no_mangle]
-pub extern "C" fn wr_api_set_window_parameters(api: &mut WrAPI,
+pub extern "C" fn wr_api_set_window_parameters(api: &mut RenderApi,
width: i32,
height: i32) {
let size = DeviceUintSize::new(width as u32, height as u32);
api.set_window_parameters(size, DeviceUintRect::new(DeviceUintPoint::new(0, 0), size));
}
#[no_mangle]
-pub unsafe extern "C" fn wr_api_set_root_display_list(api: &mut WrAPI,
+pub unsafe extern "C" fn wr_api_set_root_display_list(api: &mut RenderApi,
color: ColorF,
epoch: WrEpoch,
viewport_width: f32,
viewport_height: f32,
pipeline_id: WrPipelineId,
content_size: LayoutSize,
- dl_descriptor: WrBuiltDisplayListDescriptor,
+ dl_descriptor: BuiltDisplayListDescriptor,
dl_data: *mut u8,
dl_size: usize) {
let color = if color.a == 0.0 {
None
} else {
Some(color.into())
};
// See the documentation of set_display_list in api.rs. I don't think
@@ -731,36 +722,36 @@ pub unsafe extern "C" fn wr_api_set_root
api.set_display_list(color,
epoch,
LayoutSize::new(viewport_width, viewport_height),
(pipeline_id, content_size.into(), dl),
preserve_frame_state);
}
#[no_mangle]
-pub unsafe extern "C" fn wr_api_clear_root_display_list(api: &mut WrAPI,
+pub unsafe extern "C" fn wr_api_clear_root_display_list(api: &mut RenderApi,
epoch: WrEpoch,
pipeline_id: WrPipelineId) {
let preserve_frame_state = true;
let frame_builder = WebRenderFrameBuilder::new(pipeline_id, LayoutSize::zero());
api.set_display_list(None,
epoch,
LayoutSize::new(0.0, 0.0),
frame_builder.dl_builder.finalize(),
preserve_frame_state);
}
#[no_mangle]
-pub extern "C" fn wr_api_generate_frame(api: &mut WrAPI) {
+pub extern "C" fn wr_api_generate_frame(api: &mut RenderApi) {
api.generate_frame(None);
}
#[no_mangle]
-pub extern "C" fn wr_api_generate_frame_with_properties(api: &mut WrAPI,
+pub extern "C" fn wr_api_generate_frame_with_properties(api: &mut RenderApi,
opacity_array: *const WrOpacityProperty,
opacity_count: usize,
transform_array: *const WrTransformProperty,
transform_count: usize) {
let mut properties = DynamicProperties {
transforms: Vec::new(),
floats: Vec::new(),
};
@@ -790,47 +781,47 @@ pub extern "C" fn wr_api_generate_frame_
}
}
api.generate_frame(Some(properties));
}
/// cbindgen:postfix=WR_DESTRUCTOR_SAFE_FUNC
#[no_mangle]
-pub extern "C" fn wr_api_send_external_event(api: &mut WrAPI,
+pub extern "C" fn wr_api_send_external_event(api: &mut RenderApi,
evt: usize) {
assert!(unsafe { !is_in_render_thread() });
api.send_external_event(ExternalEvent::from_raw(evt));
}
#[no_mangle]
-pub extern "C" fn wr_api_add_raw_font(api: &mut WrAPI,
+pub extern "C" fn wr_api_add_raw_font(api: &mut RenderApi,
key: WrFontKey,
font_buffer: *mut u8,
buffer_size: usize,
index: u32) {
assert!(unsafe { is_in_compositor_thread() });
let font_slice = make_slice(font_buffer, buffer_size);
let mut font_vector = Vec::new();
font_vector.extend_from_slice(font_slice);
api.add_raw_font(key, font_vector, index);
}
#[no_mangle]
-pub extern "C" fn wr_api_delete_font(api: &mut WrAPI,
+pub extern "C" fn wr_api_delete_font(api: &mut RenderApi,
key: WrFontKey) {
assert!(unsafe { is_in_compositor_thread() });
api.delete_font(key);
}
#[no_mangle]
-pub unsafe extern "C" fn wr_api_get_namespace(api: &mut WrAPI) -> WrIdNamespace {
+pub unsafe extern "C" fn wr_api_get_namespace(api: &mut RenderApi) -> WrIdNamespace {
api.id_namespace
}
// RenderThread WIP notes:
// In order to separate the compositor thread (or ipc receiver) and the render
// thread, some of the logic below needs to be rewritten. In particular
// the WrWindowState and Notifier implementations aren't designed to work with
// a separate render thread.
@@ -914,18 +905,18 @@ pub extern "C" fn wr_dp_end(state: &mut
}
#[no_mangle]
pub extern "C" fn wr_dp_push_stacking_context(state: &mut WrState,
bounds: LayoutRect,
animation_id: u64,
opacity: *const f32,
transform: *const LayoutTransform,
- transform_style: WrTransformStyle,
- mix_blend_mode: WrMixBlendMode,
+ transform_style: TransformStyle,
+ mix_blend_mode: MixBlendMode,
filters: *const WrFilterOp,
filter_count: usize) {
assert!(unsafe { !is_in_render_thread() });
let bounds = bounds.into();
let c_filters = make_slice(filters, filter_count);
let mut filters : Vec<FilterOp> = c_filters.iter().map(|c_filter| {
@@ -1030,17 +1021,17 @@ pub extern "C" fn wr_dp_push_scroll_laye
#[no_mangle]
pub extern "C" fn wr_dp_pop_scroll_layer(state: &mut WrState) {
assert!(unsafe { is_in_main_thread() });
state.frame_builder.dl_builder.pop_clip_id();
}
#[no_mangle]
-pub extern "C" fn wr_scroll_layer_with_id(api: &mut WrAPI,
+pub extern "C" fn wr_scroll_layer_with_id(api: &mut RenderApi,
pipeline_id: WrPipelineId,
scroll_id: u64,
new_scroll_origin: LayoutPoint) {
assert!(unsafe { is_in_compositor_thread() });
let clip_id = ClipId::new(scroll_id, pipeline_id);
api.scroll_node_with_id(new_scroll_origin.into(), clip_id, ScrollClamping::NoClamping);
}
@@ -1088,17 +1079,17 @@ pub extern "C" fn wr_dp_push_rect(state:
}
#[no_mangle]
pub extern "C" fn wr_dp_push_image(state: &mut WrState,
bounds: LayoutRect,
clip: LayoutRect,
stretch_size: LayoutSize,
tile_spacing: LayoutSize,
- image_rendering: WrImageRendering,
+ image_rendering: ImageRendering,
key: WrImageKey) {
assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
state.frame_builder
.dl_builder
.push_image(bounds.into(),
Some(LocalClip::Rect(clip.into())),
stretch_size.into(),
@@ -1111,17 +1102,17 @@ pub extern "C" fn wr_dp_push_image(state
#[no_mangle]
pub extern "C" fn wr_dp_push_yuv_planar_image(state: &mut WrState,
bounds: LayoutRect,
clip: LayoutRect,
image_key_0: WrImageKey,
image_key_1: WrImageKey,
image_key_2: WrImageKey,
color_space: WrYuvColorSpace,
- image_rendering: WrImageRendering) {
+ image_rendering: ImageRendering) {
assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
state.frame_builder
.dl_builder
.push_yuv_image(bounds.into(),
Some(LocalClip::Rect(clip.into())),
YuvData::PlanarYCbCr(image_key_0, image_key_1, image_key_2),
color_space,
@@ -1131,17 +1122,17 @@ pub extern "C" fn wr_dp_push_yuv_planar_
/// Push a 2 planar NV12 image.
#[no_mangle]
pub extern "C" fn wr_dp_push_yuv_NV12_image(state: &mut WrState,
bounds: LayoutRect,
clip: LayoutRect,
image_key_0: WrImageKey,
image_key_1: WrImageKey,
color_space: WrYuvColorSpace,
- image_rendering: WrImageRendering) {
+ image_rendering: ImageRendering) {
assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
state.frame_builder
.dl_builder
.push_yuv_image(bounds.into(),
Some(LocalClip::Rect(clip.into())),
YuvData::NV12(image_key_0, image_key_1),
color_space,
@@ -1150,17 +1141,17 @@ pub extern "C" fn wr_dp_push_yuv_NV12_im
/// Push a yuv interleaved image.
#[no_mangle]
pub extern "C" fn wr_dp_push_yuv_interleaved_image(state: &mut WrState,
bounds: LayoutRect,
clip: LayoutRect,
image_key_0: WrImageKey,
color_space: WrYuvColorSpace,
- image_rendering: WrImageRendering) {
+ image_rendering: ImageRendering) {
assert!(unsafe { is_in_main_thread() || is_in_compositor_thread() });
state.frame_builder
.dl_builder
.push_yuv_image(bounds.into(),
Some(LocalClip::Rect(clip.into())),
YuvData::InterleavedYCbCr(image_key_0),
color_space,
@@ -1385,17 +1376,17 @@ pub extern "C" fn wr_dp_push_box_shadow(
rect: LayoutRect,
clip: LayoutRect,
box_bounds: LayoutRect,
offset: LayoutVector2D,
color: ColorF,
blur_radius: f32,
spread_radius: f32,
border_radius: f32,
- clip_mode: WrBoxShadowClipMode) {
+ clip_mode: BoxShadowClipMode) {
assert!(unsafe { is_in_main_thread() });
state.frame_builder
.dl_builder
.push_box_shadow(rect.into(),
Some(LocalClip::Rect(clip.into())),
box_bounds.into(),
offset,
@@ -1404,31 +1395,31 @@ pub extern "C" fn wr_dp_push_box_shadow(
spread_radius,
border_radius,
clip_mode);
}
#[no_mangle]
pub unsafe extern "C" fn wr_api_finalize_builder(state: &mut WrState,
content_size: &mut LayoutSize,
- dl_descriptor: &mut WrBuiltDisplayListDescriptor,
+ dl_descriptor: &mut BuiltDisplayListDescriptor,
dl_data: &mut WrVecU8) {
let frame_builder = mem::replace(&mut state.frame_builder,
WebRenderFrameBuilder::new(state.pipeline_id,
LayoutSize::zero()));
let (_, size, dl) = frame_builder.dl_builder.finalize();
*content_size = LayoutSize::new(size.width, size.height);
let (data, descriptor) = dl.into_data();
*dl_data = WrVecU8::from_vec(data);
*dl_descriptor = descriptor;
}
#[no_mangle]
pub extern "C" fn wr_dp_push_built_display_list(state: &mut WrState,
- dl_descriptor: WrBuiltDisplayListDescriptor,
+ dl_descriptor: BuiltDisplayListDescriptor,
dl_data: &mut WrVecU8) {
let dl_vec = mem::replace(dl_data, WrVecU8::from_vec(Vec::new())).to_vec();
let dl = BuiltDisplayList::from_data(dl_vec, dl_descriptor);
state.frame_builder.dl_builder.push_nested_display_list(&dl);
let (data, _) = dl.into_data();
mem::replace(dl_data, WrVecU8::from_vec(data));
@@ -1437,12 +1428,12 @@ pub extern "C" fn wr_dp_push_built_displ
// TODO: nical
// Update for the new blob image interface changes.
//
extern "C" {
// TODO: figure out the API for tiled blob images.
pub fn wr_moz2d_render_cb(blob: ByteSlice,
width: u32,
height: u32,
- format: WrImageFormat,
+ format: ImageFormat,
output: MutByteSlice)
-> bool;
}
--- a/gfx/webrender_bindings/webrender_ffi_generated.h
+++ b/gfx/webrender_bindings/webrender_ffi_generated.h
@@ -29,36 +29,83 @@ enum class BorderStyle : uint32_t {
Groove = 6,
Ridge = 7,
Inset = 8,
Outset = 9,
Sentinel /* this must be last for serialization purposes. */
};
+enum class BoxShadowClipMode : uint32_t {
+ None = 0,
+ Outset = 1,
+ Inset = 2,
+
+ Sentinel /* this must be last for serialization purposes. */
+};
+
enum class ExtendMode : uint32_t {
Clamp = 0,
Repeat = 1,
Sentinel /* this must be last for serialization purposes. */
};
+enum class ImageFormat : uint32_t {
+ Invalid = 0,
+ A8 = 1,
+ RGB8 = 2,
+ BGRA8 = 3,
+ RGBAF32 = 4,
+ RG8 = 5,
+
+ Sentinel /* this must be last for serialization purposes. */
+};
+
+enum class ImageRendering : uint32_t {
+ Auto = 0,
+ CrispEdges = 1,
+ Pixelated = 2,
+
+ Sentinel /* this must be last for serialization purposes. */
+};
+
+enum class MixBlendMode : uint32_t {
+ Normal = 0,
+ Multiply = 1,
+ Screen = 2,
+ Overlay = 3,
+ Darken = 4,
+ Lighten = 5,
+ ColorDodge = 6,
+ ColorBurn = 7,
+ HardLight = 8,
+ SoftLight = 9,
+ Difference = 10,
+ Exclusion = 11,
+ Hue = 12,
+ Saturation = 13,
+ Color = 14,
+ Luminosity = 15,
+
+ Sentinel /* this must be last for serialization purposes. */
+};
+
enum class RepeatMode : uint32_t {
Stretch = 0,
Repeat = 1,
Round = 2,
Space = 3,
Sentinel /* this must be last for serialization purposes. */
};
-enum class WrBoxShadowClipMode : uint32_t {
- None = 0,
- Outset = 1,
- Inset = 2,
+enum class TransformStyle : uint32_t {
+ Flat = 0,
+ Preserve3D = 1,
Sentinel /* this must be last for serialization purposes. */
};
enum class WrExternalImageBufferType : uint32_t {
Texture2DHandle = 0,
TextureRectHandle = 1,
TextureExternalHandle = 2,
@@ -83,94 +130,47 @@ enum class WrFilterOpType : uint32_t {
Invert = 5,
Opacity = 6,
Saturate = 7,
Sepia = 8,
Sentinel /* this must be last for serialization purposes. */
};
-enum class WrImageFormat : uint32_t {
- Invalid = 0,
- A8 = 1,
- RGB8 = 2,
- BGRA8 = 3,
- RGBAF32 = 4,
- RG8 = 5,
-
- Sentinel /* this must be last for serialization purposes. */
-};
-
-enum class WrImageRendering : uint32_t {
- Auto = 0,
- CrispEdges = 1,
- Pixelated = 2,
-
- Sentinel /* this must be last for serialization purposes. */
-};
-
-enum class WrMixBlendMode : uint32_t {
- Normal = 0,
- Multiply = 1,
- Screen = 2,
- Overlay = 3,
- Darken = 4,
- Lighten = 5,
- ColorDodge = 6,
- ColorBurn = 7,
- HardLight = 8,
- SoftLight = 9,
- Difference = 10,
- Exclusion = 11,
- Hue = 12,
- Saturation = 13,
- Color = 14,
- Luminosity = 15,
-
- Sentinel /* this must be last for serialization purposes. */
-};
-
-enum class WrTransformStyle : uint32_t {
- Flat = 0,
- Preserve3D = 1,
-
- Sentinel /* this must be last for serialization purposes. */
-};
-
enum class WrYuvColorSpace : uint32_t {
Rec601 = 0,
Rec709 = 1,
Sentinel /* this must be last for serialization purposes. */
};
struct LayerPixel;
-struct WrAPI;
+struct RenderApi;
+
+struct Renderer;
struct WrRenderedEpochs;
-struct WrRenderer;
-
struct WrState;
struct WrThreadPool;
struct WrImageKey {
uint32_t mNamespace;
uint32_t mHandle;
bool operator==(const WrImageKey& aOther) const {
return mNamespace == aOther.mNamespace &&
mHandle == aOther.mHandle;
}
};
struct WrImageDescriptor {
- WrImageFormat format;
+ ImageFormat format;
uint32_t width;
uint32_t height;
uint32_t stride;
bool is_opaque;
bool operator==(const WrImageDescriptor& aOther) const {
return format == aOther.format &&
width == aOther.width &&
@@ -237,21 +237,21 @@ struct LayoutSize {
float height;
bool operator==(const LayoutSize& aOther) const {
return width == aOther.width &&
height == aOther.height;
}
};
-struct WrBuiltDisplayListDescriptor {
+struct BuiltDisplayListDescriptor {
uint64_t builder_start_time;
uint64_t builder_finish_time;
- bool operator==(const WrBuiltDisplayListDescriptor& aOther) const {
+ bool operator==(const BuiltDisplayListDescriptor& aOther) const {
return builder_start_time == aOther.builder_start_time &&
builder_finish_time == aOther.builder_finish_time;
}
};
struct WrVecU8 {
uint8_t *data;
size_t length;
@@ -590,127 +590,127 @@ struct WrExternalImageHandler {
/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
* To generate this file:
* 1. Get the latest cbindgen using `cargo install --force cbindgen`
* a. Alternatively, you can clone `https://github.com/rlhunt/cbindgen` and use a tagged release
* 2. Run `cbindgen toolkit/library/rust/ --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
*/
WR_INLINE
-void wr_api_add_blob_image(WrAPI *aApi,
+void wr_api_add_blob_image(RenderApi *aApi,
WrImageKey aImageKey,
const WrImageDescriptor *aDescriptor,
ByteSlice aBytes)
WR_FUNC;
WR_INLINE
-void wr_api_add_external_image(WrAPI *aApi,
+void wr_api_add_external_image(RenderApi *aApi,
WrImageKey aImageKey,
const WrImageDescriptor *aDescriptor,
WrExternalImageId aExternalImageId,
WrExternalImageBufferType aBufferType,
uint8_t aChannelIndex)
WR_FUNC;
WR_INLINE
-void wr_api_add_external_image_buffer(WrAPI *aApi,
+void wr_api_add_external_image_buffer(RenderApi *aApi,
WrImageKey aImageKey,
const WrImageDescriptor *aDescriptor,
WrExternalImageId aExternalImageId)
WR_FUNC;
WR_INLINE
-void wr_api_add_image(WrAPI *aApi,
+void wr_api_add_image(RenderApi *aApi,
WrImageKey aImageKey,
const WrImageDescriptor *aDescriptor,
ByteSlice aBytes)
WR_FUNC;
WR_INLINE
-void wr_api_add_raw_font(WrAPI *aApi,
+void wr_api_add_raw_font(RenderApi *aApi,
WrFontKey aKey,
uint8_t *aFontBuffer,
size_t aBufferSize,
uint32_t aIndex)
WR_FUNC;
WR_INLINE
-void wr_api_clear_root_display_list(WrAPI *aApi,
+void wr_api_clear_root_display_list(RenderApi *aApi,
WrEpoch aEpoch,
WrPipelineId aPipelineId)
WR_FUNC;
WR_INLINE
-void wr_api_delete(WrAPI *aApi)
+void wr_api_delete(RenderApi *aApi)
WR_DESTRUCTOR_SAFE_FUNC;
WR_INLINE
-void wr_api_delete_font(WrAPI *aApi,
+void wr_api_delete_font(RenderApi *aApi,
WrFontKey aKey)
WR_FUNC;
WR_INLINE
-void wr_api_delete_image(WrAPI *aApi,
+void wr_api_delete_image(RenderApi *aApi,
WrImageKey aKey)
WR_FUNC;
WR_INLINE
void wr_api_finalize_builder(WrState *aState,
LayoutSize *aContentSize,
- WrBuiltDisplayListDescriptor *aDlDescriptor,
+ BuiltDisplayListDescriptor *aDlDescriptor,
WrVecU8 *aDlData)
WR_FUNC;
WR_INLINE
-void wr_api_generate_frame(WrAPI *aApi)
+void wr_api_generate_frame(RenderApi *aApi)
WR_FUNC;
WR_INLINE
-void wr_api_generate_frame_with_properties(WrAPI *aApi,
+void wr_api_generate_frame_with_properties(RenderApi *aApi,
const WrOpacityProperty *aOpacityArray,
size_t aOpacityCount,
const WrTransformProperty *aTransformArray,
size_t aTransformCount)
WR_FUNC;
WR_INLINE
-WrIdNamespace wr_api_get_namespace(WrAPI *aApi)
+WrIdNamespace wr_api_get_namespace(RenderApi *aApi)
WR_FUNC;
WR_INLINE
-void wr_api_send_external_event(WrAPI *aApi,
+void wr_api_send_external_event(RenderApi *aApi,
size_t aEvt)
WR_DESTRUCTOR_SAFE_FUNC;
WR_INLINE
-void wr_api_set_root_display_list(WrAPI *aApi,
+void wr_api_set_root_display_list(RenderApi *aApi,
ColorF aColor,
WrEpoch aEpoch,
float aViewportWidth,
float aViewportHeight,
WrPipelineId aPipelineId,
LayoutSize aContentSize,
- WrBuiltDisplayListDescriptor aDlDescriptor,
+ BuiltDisplayListDescriptor aDlDescriptor,
uint8_t *aDlData,
size_t aDlSize)
WR_FUNC;
WR_INLINE
-void wr_api_set_root_pipeline(WrAPI *aApi,
+void wr_api_set_root_pipeline(RenderApi *aApi,
WrPipelineId aPipelineId)
WR_FUNC;
WR_INLINE
-void wr_api_set_window_parameters(WrAPI *aApi,
+void wr_api_set_window_parameters(RenderApi *aApi,
int32_t aWidth,
int32_t aHeight)
WR_FUNC;
WR_INLINE
-void wr_api_update_image(WrAPI *aApi,
+void wr_api_update_image(RenderApi *aApi,
WrImageKey aKey,
const WrImageDescriptor *aDescriptor,
ByteSlice aBytes)
WR_FUNC;
WR_INLINE
void wr_dp_begin(WrState *aState,
uint32_t aWidth,
@@ -792,22 +792,22 @@ void wr_dp_push_box_shadow(WrState *aSta
LayoutRect aRect,
LayoutRect aClip,
LayoutRect aBoxBounds,
LayoutVector2D aOffset,
ColorF aColor,
float aBlurRadius,
float aSpreadRadius,
float aBorderRadius,
- WrBoxShadowClipMode aClipMode)
+ BoxShadowClipMode aClipMode)
WR_FUNC;
WR_INLINE
void wr_dp_push_built_display_list(WrState *aState,
- WrBuiltDisplayListDescriptor aDlDescriptor,
+ BuiltDisplayListDescriptor aDlDescriptor,
WrVecU8 *aDlData)
WR_FUNC;
WR_INLINE
uint64_t wr_dp_push_clip(WrState *aState,
LayoutRect aRect,
const WrComplexClipRegion *aComplex,
size_t aComplexCount,
@@ -827,17 +827,17 @@ void wr_dp_push_iframe(WrState *aState,
WR_FUNC;
WR_INLINE
void wr_dp_push_image(WrState *aState,
LayoutRect aBounds,
LayoutRect aClip,
LayoutSize aStretchSize,
LayoutSize aTileSpacing,
- WrImageRendering aImageRendering,
+ ImageRendering aImageRendering,
WrImageKey aKey)
WR_FUNC;
WR_INLINE
void wr_dp_push_linear_gradient(WrState *aState,
LayoutRect aRect,
LayoutRect aClip,
LayoutPoint aStartPoint,
@@ -877,18 +877,18 @@ void wr_dp_push_scroll_layer(WrState *aS
WR_FUNC;
WR_INLINE
void wr_dp_push_stacking_context(WrState *aState,
LayoutRect aBounds,
uint64_t aAnimationId,
const float *aOpacity,
const LayoutTransform *aTransform,
- WrTransformStyle aTransformStyle,
- WrMixBlendMode aMixBlendMode,
+ TransformStyle aTransformStyle,
+ MixBlendMode aMixBlendMode,
const WrFilterOp *aFilters,
size_t aFilterCount)
WR_FUNC;
WR_INLINE
void wr_dp_push_text(WrState *aState,
LayoutRect aBounds,
LayoutRect aClip,
@@ -901,93 +901,93 @@ WR_FUNC;
WR_INLINE
void wr_dp_push_yuv_NV12_image(WrState *aState,
LayoutRect aBounds,
LayoutRect aClip,
WrImageKey aImageKey0,
WrImageKey aImageKey1,
WrYuvColorSpace aColorSpace,
- WrImageRendering aImageRendering)
+ ImageRendering aImageRendering)
WR_FUNC;
WR_INLINE
void wr_dp_push_yuv_interleaved_image(WrState *aState,
LayoutRect aBounds,
LayoutRect aClip,
WrImageKey aImageKey0,
WrYuvColorSpace aColorSpace,
- WrImageRendering aImageRendering)
+ ImageRendering aImageRendering)
WR_FUNC;
WR_INLINE
void wr_dp_push_yuv_planar_image(WrState *aState,
LayoutRect aBounds,
LayoutRect aClip,
WrImageKey aImageKey0,
WrImageKey aImageKey1,
WrImageKey aImageKey2,
WrYuvColorSpace aColorSpace,
- WrImageRendering aImageRendering)
+ ImageRendering aImageRendering)
WR_FUNC;
WR_INLINE
void wr_rendered_epochs_delete(WrRenderedEpochs *aPipelineEpochs)
WR_DESTRUCTOR_SAFE_FUNC;
WR_INLINE
bool wr_rendered_epochs_next(WrRenderedEpochs *aPipelineEpochs,
WrPipelineId *aOutPipeline,
WrEpoch *aOutEpoch)
WR_FUNC;
WR_INLINE
-bool wr_renderer_current_epoch(WrRenderer *aRenderer,
+bool wr_renderer_current_epoch(Renderer *aRenderer,
WrPipelineId aPipelineId,
WrEpoch *aOutEpoch)
WR_FUNC;
WR_INLINE
-void wr_renderer_delete(WrRenderer *aRenderer)
+void wr_renderer_delete(Renderer *aRenderer)
WR_DESTRUCTOR_SAFE_FUNC;
WR_INLINE
-WrRenderedEpochs *wr_renderer_flush_rendered_epochs(WrRenderer *aRenderer)
+WrRenderedEpochs *wr_renderer_flush_rendered_epochs(Renderer *aRenderer)
WR_FUNC;
WR_INLINE
-void wr_renderer_readback(WrRenderer *aRenderer,
+void wr_renderer_readback(Renderer *aRenderer,
uint32_t aWidth,
uint32_t aHeight,
uint8_t *aDstBuffer,
size_t aBufferSize)
WR_FUNC;
WR_INLINE
-void wr_renderer_render(WrRenderer *aRenderer,
+void wr_renderer_render(Renderer *aRenderer,
uint32_t aWidth,
uint32_t aHeight)
WR_FUNC;
WR_INLINE
-void wr_renderer_set_external_image_handler(WrRenderer *aRenderer,
+void wr_renderer_set_external_image_handler(Renderer *aRenderer,
WrExternalImageHandler *aExternalImageHandler)
WR_FUNC;
WR_INLINE
-void wr_renderer_set_profiler_enabled(WrRenderer *aRenderer,
+void wr_renderer_set_profiler_enabled(Renderer *aRenderer,
bool aEnabled)
WR_FUNC;
WR_INLINE
-void wr_renderer_update(WrRenderer *aRenderer)
+void wr_renderer_update(Renderer *aRenderer)
WR_FUNC;
WR_INLINE
-void wr_scroll_layer_with_id(WrAPI *aApi,
+void wr_scroll_layer_with_id(RenderApi *aApi,
WrPipelineId aPipelineId,
uint64_t aScrollId,
LayoutPoint aNewScrollOrigin)
WR_FUNC;
WR_INLINE
void wr_state_delete(WrState *aState)
WR_DESTRUCTOR_SAFE_FUNC;
@@ -1011,18 +1011,18 @@ WR_FUNC;
WR_INLINE
bool wr_window_new(WrWindowId aWindowId,
uint32_t aWindowWidth,
uint32_t aWindowHeight,
void *aGlContext,
WrThreadPool *aThreadPool,
bool aEnableProfiler,
- WrAPI **aOutApi,
- WrRenderer **aOutRenderer)
+ RenderApi **aOutApi,
+ Renderer **aOutRenderer)
WR_FUNC;
} // namespace wr
} // namespace mozilla
} // extern "C"
/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -471,17 +471,17 @@ BulletRenderer::CreateWebRenderCommandsF
}
const int32_t appUnitsPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
LayoutDeviceRect destRect = LayoutDeviceRect::FromAppUnits(mDest, appUnitsPerDevPixel);
wr::LayoutRect dest = aSc.ToRelativeLayoutRectRounded(destRect);
aBuilder.PushImage(dest,
dest,
- wr::WrImageRendering::Auto,
+ wr::ImageRendering::Auto,
key.value());
}
void
BulletRenderer::CreateWebRenderCommandsForPath(nsDisplayItem* aItem,
wr::DisplayListBuilder& aBuilder,
const layers::StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands,
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -5361,17 +5361,17 @@ nsDisplayBoxShadowOuter::CreateWebRender
aBuilder.PushBoxShadow(deviceBoxRect,
deviceClipRect,
deviceBoxRect,
wr::ToLayoutVector2D(shadowOffset),
wr::ToColorF(shadowColor),
blurRadius,
spreadRadius,
borderRadius,
- wr::WrBoxShadowClipMode::Outset);
+ wr::BoxShadowClipMode::Outset);
}
}
return true;
}
void
nsDisplayBoxShadowOuter::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
@@ -5519,17 +5519,17 @@ nsDisplayBoxShadowInner::CreateInsetBoxS
aBuilder.PushBoxShadow(wr::ToLayoutRect(deviceBoxRect),
deviceClipRect,
wr::ToLayoutRect(deviceBoxRect),
wr::ToLayoutVector2D(shadowOffset),
wr::ToColorF(shadowColor),
blurRadius,
spreadRadius,
borderRadius,
- wr::WrBoxShadowClipMode::Inset
+ wr::BoxShadowClipMode::Inset
);
}
}
}
bool
nsDisplayBoxShadowInner::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,