--- a/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
+++ b/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
@@ -6,18 +6,18 @@
 #include "WebRenderDisplayItemLayer.h"
 
 #include "LayersLogging.h"
 #include "mozilla/webrender/webrender_ffi.h"
 #include "mozilla/webrender/WebRenderTypes.h"
 #include "mozilla/layers/StackingContextHelper.h"
 #include "mozilla/layers/WebRenderBridgeChild.h"
 #include "nsDisplayList.h"
+#include "mozilla/gfx/DrawEventRecorder.h"
 #include "mozilla/gfx/Matrix.h"
-#include "mozilla/layers/UpdateImageHelper.h"
 #include "UnitTransforms.h"
 
 namespace mozilla {
 namespace layers {
 
 WebRenderDisplayItemLayer::~WebRenderDisplayItemLayer()
 {
   MOZ_COUNT_DTOR(WebRenderDisplayItemLayer);
@@ -125,80 +125,58 @@ WebRenderDisplayItemLayer::SendImageCont
 
     mImageContainer = aContainer;
   }
 
   return mKey;
 }
 
 bool
-WebRenderDisplayItemLayer::PushItemAsImage(wr::DisplayListBuilder& aBuilder,
-                                           const StackingContextHelper& aSc,
-                                           nsTArray<layers::WebRenderParentCommand>& aParentCommands)
+WebRenderDisplayItemLayer::PushItemAsBlobImage(wr::DisplayListBuilder& aBuilder,
+                                               const StackingContextHelper& aSc)
 {
-  if (!mImageContainer) {
-    mImageContainer = LayerManager::CreateImageContainer();
-  }
-
-  if (!mImageClient) {
-    mImageClient = ImageClient::CreateImageClient(CompositableType::IMAGE,
-                                                  WrBridge(),
-                                                  TextureFlags::DEFAULT);
-    if (!mImageClient) {
-      return false;
-    }
-    mImageClient->Connect();
-  }
-
-  if (mExternalImageId.isNothing()) {
-    MOZ_ASSERT(mImageClient);
-    mExternalImageId = Some(WrBridge()->AllocExternalImageIdForCompositable(mImageClient));
-  }
-
   const int32_t appUnitsPerDevPixel = mItem->Frame()->PresContext()->AppUnitsPerDevPixel();
 
   bool snap;
   LayerRect bounds = ViewAs<LayerPixel>(
       LayoutDeviceRect::FromAppUnits(mItem->GetBounds(mBuilder, &snap), appUnitsPerDevPixel),
       PixelCastJustification::WebRenderHasUnitResolution);
   LayerIntSize imageSize = RoundedToInt(bounds.Size());
   LayerRect imageRect;
   imageRect.SizeTo(LayerSize(imageSize));
 
-  UpdateImageHelper helper(mImageContainer, mImageClient, imageSize.ToUnknownSize());
+  RefPtr<gfx::DrawEventRecorderMemory> recorder = MakeAndAddRef<gfx::DrawEventRecorderMemory>();
+  RefPtr<gfx::DrawTarget> dummyDt =
+    gfx::Factory::CreateDrawTarget(gfx::BackendType::SKIA, imageSize.ToUnknownSize(), gfx::SurfaceFormat::B8G8R8X8);
+  RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateRecordingDrawTarget(recorder, dummyDt);
   LayerPoint offset = ViewAs<LayerPixel>(
       LayoutDevicePoint::FromAppUnits(mItem->ToReferenceFrame(), appUnitsPerDevPixel),
       PixelCastJustification::WebRenderHasUnitResolution);
 
   {
-    RefPtr<gfx::DrawTarget> target = helper.GetDrawTarget();
-    if (!target) {
-      return false;
-    }
-
-    target->ClearRect(imageRect.ToUnknownRect());
-    RefPtr<gfxContext> context = gfxContext::CreateOrNull(target, offset.ToUnknownPoint());
+    dt->ClearRect(imageRect.ToUnknownRect());
+    RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt, offset.ToUnknownPoint());
     MOZ_ASSERT(context);
 
     nsRenderingContext ctx(context);
     mItem->Paint(mBuilder, &ctx);
   }
 
-  if (!helper.UpdateImage()) {
-    return false;
-  }
+  wr::ByteBuffer bytes;
+  bytes.Allocate(recorder->RecordingSize());
+  DebugOnly<bool> ok = recorder->CopyRecording((char*)bytes.AsSlice().begin().get(), bytes.AsSlice().length());
+  MOZ_ASSERT(ok);
 
   WrRect dest = aSc.ToRelativeWrRect(imageRect + offset);
   WrClipRegion clipRegion = aBuilder.BuildClipRegion(dest);
   WrImageKey key = GetImageKey();
-  aParentCommands.AppendElement(layers::OpAddExternalImage(
-                                mExternalImageId.value(),
-                                key));
+  WrBridge()->SendAddBlobImage(key, imageSize.ToUnknownSize(), imageSize.width * 4, dt->GetFormat(), bytes);
+  WrManager()->AddImageKeyForDiscard(key);
+
   aBuilder.PushImage(dest,
                      clipRegion,
-                     WrImageRendering::Auto,
+                     wr::ImageRendering::Auto,
                      key);
-
   return true;
 }
 
 } // namespace layers
 } // namespace mozilla

--- a/gfx/layers/wr/WebRenderDisplayItemLayer.h
+++ b/gfx/layers/wr/WebRenderDisplayItemLayer.h
@@ -23,19 +23,18 @@ public:
   explicit WebRenderDisplayItemLayer(WebRenderLayerManager* aLayerManager)
     : DisplayItemLayer(aLayerManager, static_cast<WebRenderLayer*>(this))
   {
     MOZ_COUNT_CTOR(WebRenderDisplayItemLayer);
   }
 
   Maybe<wr::ImageKey> SendImageContainer(ImageContainer* aContainer,
                                          nsTArray<layers::WebRenderParentCommand>& aParentCommands);
-  bool PushItemAsImage(wr::DisplayListBuilder& aBuilder,
-                       const StackingContextHelper& aSc,
-                       nsTArray<layers::WebRenderParentCommand>& aParentCommands);
+  bool PushItemAsBlobImage(wr::DisplayListBuilder& aBuilder,
+                           const StackingContextHelper& aSc);
 
 protected:
   virtual ~WebRenderDisplayItemLayer();
 
 public:
   Layer* GetLayer() override { return this; }
   void RenderLayer(wr::DisplayListBuilder& aBuilder,
                    const StackingContextHelper& aHelper) override;

--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -481,17 +481,17 @@ BulletRenderer::CreateWebRenderCommandsF
                                                wr::DisplayListBuilder& aBuilder,
                                                const layers::StackingContextHelper& aSc,
                                                nsTArray<layers::WebRenderParentCommand>& aParentCommands,
                                                layers::WebRenderDisplayItemLayer* aLayer)
 {
   MOZ_ASSERT(IsPathType());
   MOZ_ASSERT(aLayer->GetDisplayItem() == aItem);
 
-  if (!aLayer->PushItemAsImage(aBuilder, aSc, aParentCommands)) {
+  if (!aLayer->PushItemAsBlobImage(aBuilder, aSc)) {
     NS_WARNING("Fail to create WebRender commands for Bullet path.");
   }
 }
 
 void
 BulletRenderer::CreateWebRenderCommandsForText(nsDisplayItem* aItem,
                                                wr::DisplayListBuilder& aBuilder,
                                                const layers::StackingContextHelper& aSc,