Bug 1382128 part 8 - Remove Wr prefix from some type aliases. r=kats
authorRyan Hunt <rhunt@eqrion.net>
Wed, 19 Jul 2017 03:28:58 -0400
changeset 369725 3e1508068c1b3158a3fb5373269922ef289dc5d4
parent 369724 792d552a2bcc330efc49e3bee7e5a3865e317874
child 369726 ae4ec8080af6dbffc046e8699c8246f564046362
push id32202
push userkwierso@gmail.com
push dateThu, 20 Jul 2017 00:30:04 +0000
treeherdermozilla-central@eb1d92b2b6a4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskats
bugs1382128
milestone56.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1382128 part 8 - Remove Wr prefix from some type aliases. r=kats MozReview-Commit-ID: 5h7QobhcYc1
gfx/layers/ipc/PWebRenderBridge.ipdl
gfx/layers/ipc/WebRenderMessages.ipdlh
gfx/layers/wr/StackingContextHelper.cpp
gfx/layers/wr/WebRenderBridgeParent.cpp
gfx/layers/wr/WebRenderBridgeParent.h
gfx/layers/wr/WebRenderCompositableHolder.cpp
gfx/layers/wr/WebRenderCompositableHolder.h
gfx/layers/wr/WebRenderImageLayer.cpp
gfx/layers/wr/WebRenderLayer.cpp
gfx/layers/wr/WebRenderMessageUtils.h
gfx/layers/wr/WebRenderUserData.cpp
gfx/layers/wr/WebRenderUserData.h
gfx/webrender_bindings/Moz2DImageRenderer.cpp
gfx/webrender_bindings/RendererOGL.cpp
gfx/webrender_bindings/RendererOGL.h
gfx/webrender_bindings/WebRenderAPI.cpp
gfx/webrender_bindings/WebRenderAPI.h
gfx/webrender_bindings/WebRenderTypes.h
gfx/webrender_bindings/src/bindings.rs
gfx/webrender_bindings/webrender_ffi_generated.h
layout/generic/nsBulletFrame.cpp
layout/painting/nsDisplayList.cpp
--- 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
@@ -180,17 +180,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:
@@ -604,17 +601,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,