diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 9100c15..29def71 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -1931,8 +1931,10 @@
         }
         sk_sp<SkSurface> surface = sk_ref_sp(tmp);
 
+        promiseImageHelper.createCallbackContexts(context);
+
         // This is here bc this is the first point where we have access to the context
-        promiseImageHelper.uploadAllToGPU(context);
+        promiseImageHelper.uploadAllToGPU(nullptr, context);
         // We draw N times, with a clear between.
         for (int replay = 0; replay < fNumReplays; ++replay) {
             if (replay > 0) {
diff --git a/tools/DDLPromiseImageHelper.cpp b/tools/DDLPromiseImageHelper.cpp
index e612bc4..e068a0d 100644
--- a/tools/DDLPromiseImageHelper.cpp
+++ b/tools/DDLPromiseImageHelper.cpp
@@ -14,6 +14,8 @@
 #include "include/core/SkYUVASizeInfo.h"
 #include "include/gpu/GrContext.h"
 #include "src/core/SkCachedData.h"
+#include "src/core/SkTaskGroup.h"
+#include "src/gpu/GrContextPriv.h"
 #include "src/image/SkImage_Base.h"
 #include "src/image/SkImage_GpuYUVA.h"
 
@@ -31,6 +33,7 @@
 void DDLPromiseImageHelper::PromiseImageCallbackContext::setBackendTexture(
         const GrBackendTexture& backendTexture) {
     SkASSERT(!fPromiseImageTexture);
+    SkASSERT(fBackendFormat == backendTexture.getBackendFormat());
     fPromiseImageTexture = SkPromiseImageTexture::Make(backendTexture);
 }
 
@@ -71,42 +74,107 @@
     return context->createBackendTexture(&pm, 1, GrRenderable::kNo, GrProtected::kNo);
 }
 
-void DDLPromiseImageHelper::uploadAllToGPU(GrContext* context) {
-    for (int i = 0; i < fImageInfo.count(); ++i) {
-        const PromiseImageInfo& info = fImageInfo[i];
+/*
+ * Create backend textures and upload data to them for all the textures required to satisfy
+ * a single promise image.
+ * For YUV textures this will result in up to 4 actual textures.
+ */
+void DDLPromiseImageHelper::CreateBETexturesForPromiseImage(GrContext* context,
+                                                            PromiseImageInfo* info) {
+    SkASSERT(context->priv().asDirectContext());
 
-        // DDL TODO: how can we tell if we need mipmapping!
+    // DDL TODO: how can we tell if we need mipmapping!
+    if (info->isYUV()) {
+        int numPixmaps;
+        SkAssertResult(SkYUVAIndex::AreValidIndices(info->yuvaIndices(), &numPixmaps));
+        for (int j = 0; j < numPixmaps; ++j) {
+            const SkPixmap& yuvPixmap = info->yuvPixmap(j);
+
+            PromiseImageCallbackContext* callbackContext = info->callbackContext(j);
+            SkASSERT(callbackContext);
+
+            callbackContext->setBackendTexture(create_yuva_texture(context, yuvPixmap,
+                                                                   info->yuvaIndices(), j));
+            SkASSERT(callbackContext->promiseImageTexture());
+        }
+    } else {
+        PromiseImageCallbackContext* callbackContext = info->callbackContext(0);
+        if (!callbackContext) {
+            // This texture would've been too large to fit on the GPU
+            return;
+        }
+
+        const SkBitmap& bm = info->normalBitmap();
+
+        GrBackendTexture backendTex = context->createBackendTexture(
+                                                    &bm.pixmap(), 1, GrRenderable::kNo,
+                                                    GrProtected::kNo);
+        SkASSERT(backendTex.isValid());
+
+        callbackContext->setBackendTexture(backendTex);
+    }
+}
+
+void DDLPromiseImageHelper::createCallbackContexts(GrContext* context) {
+    const GrCaps* caps = context->priv().caps();
+    const int maxDimension = caps->maxTextureSize();
+
+    for (int i = 0; i < fImageInfo.count(); ++i) {
+        PromiseImageInfo& info = fImageInfo[i];
+
         if (info.isYUV()) {
             int numPixmaps;
             SkAssertResult(SkYUVAIndex::AreValidIndices(info.yuvaIndices(), &numPixmaps));
+
             for (int j = 0; j < numPixmaps; ++j) {
                 const SkPixmap& yuvPixmap = info.yuvPixmap(j);
 
+                GrBackendFormat backendFormat = context->defaultBackendFormat(yuvPixmap.colorType(),
+                                                                              GrRenderable::kNo);
+
                 sk_sp<PromiseImageCallbackContext> callbackContext(
-                                                        new PromiseImageCallbackContext(context));
+                    new PromiseImageCallbackContext(context, backendFormat));
 
-                callbackContext->setBackendTexture(create_yuva_texture(context, yuvPixmap,
-                                                                       info.yuvaIndices(), j));
-                SkASSERT(callbackContext->promiseImageTexture());
-
-                fImageInfo[i].setCallbackContext(j, std::move(callbackContext));
+                info.setCallbackContext(j, std::move(callbackContext));
             }
         } else {
-            sk_sp<PromiseImageCallbackContext> callbackContext(
-                                                    new PromiseImageCallbackContext(context));
-
             const SkBitmap& bm = info.normalBitmap();
 
-            GrBackendTexture backendTex = context->createBackendTexture(
-                                                        &bm.pixmap(), 1, GrRenderable::kNo,
-                                                        GrProtected::kNo);
+            // TODO: explicitly mark the PromiseImageInfo as too big and check in uploadAllToGPU
+            if (maxDimension < std::max(bm.width(), bm.height())) {
+                // This won't fit on the GPU. Fallback to a raster-backed image per tile.
+                continue;
+            }
 
-            callbackContext->setBackendTexture(backendTex);
+            GrBackendFormat backendFormat = context->defaultBackendFormat(bm.pixmap().colorType(),
+                                                                          GrRenderable::kNo);
+            if (!caps->isFormatTexturable(backendFormat)) {
+                continue;
+            }
 
-            // The GMs sometimes request too large an image
-            //SkAssertResult(callbackContext->backendTexture().isValid());
 
-            fImageInfo[i].setCallbackContext(0, std::move(callbackContext));
+            sk_sp<PromiseImageCallbackContext> callbackContext(
+                new PromiseImageCallbackContext(context, backendFormat));
+
+            info.setCallbackContext(0, std::move(callbackContext));
+        }
+    }
+}
+
+void DDLPromiseImageHelper::uploadAllToGPU(SkTaskGroup* taskGroup, GrContext* context) {
+    SkASSERT(context->priv().asDirectContext());
+
+    if (taskGroup) {
+        for (int i = 0; i < fImageInfo.count(); ++i) {
+            PromiseImageInfo* info = &fImageInfo[i];
+
+            taskGroup->add([context, info]() {
+                              CreateBETexturesForPromiseImage(context, info);
+                           });
+        }
+    } else {
+        for (int i = 0; i < fImageInfo.count(); ++i) {
+            CreateBETexturesForPromiseImage(context, &fImageInfo[i]);
         }
     }
 }
@@ -119,7 +187,7 @@
 
     SkDeserialProcs procs;
     procs.fImageCtx = (void*) &perRecorderContext;
-    procs.fImageProc = PromiseImageCreator;
+    procs.fImageProc = CreatePromiseImages;
 
     return SkPicture::MakeFromData(compressedPictureData, &procs);
 }
@@ -127,7 +195,7 @@
 // This generates promise images to replace the indices in the compressed picture. This
 // reconstitution is performed separately in each thread so we end up with multiple
 // promise images referring to the same GrBackendTexture.
-sk_sp<SkImage> DDLPromiseImageHelper::PromiseImageCreator(const void* rawData,
+sk_sp<SkImage> DDLPromiseImageHelper::CreatePromiseImages(const void* rawData,
                                                           size_t length, void* ctxIn) {
     PerRecorderContext* perRecorderContext = static_cast<PerRecorderContext*>(ctxIn);
     const DDLPromiseImageHelper* helper = perRecorderContext->fHelper;
@@ -142,13 +210,13 @@
 
     const DDLPromiseImageHelper::PromiseImageInfo& curImage = helper->getInfo(*indexPtr);
 
-    if (!curImage.promiseTexture(0)) {
-        SkASSERT(!curImage.isYUV());
-        // We weren't able to make a backend texture for this SkImage. In this case we create
-        // a separate bitmap-backed image for each thread.
+    // If there is no callback context that means 'createCallbackContexts' determined the
+    // texture wouldn't fit on the GPU. Create a separate bitmap-backed image for each thread.
+    if (!curImage.isYUV() && !curImage.callbackContext(0)) {
         SkASSERT(curImage.normalBitmap().isImmutable());
         return SkImage::MakeFromBitmap(curImage.normalBitmap());
     }
+
     SkASSERT(curImage.index() == *indexPtr);
 
     sk_sp<SkImage> image;
@@ -160,8 +228,7 @@
         int textureCount;
         SkAssertResult(SkYUVAIndex::AreValidIndices(curImage.yuvaIndices(), &textureCount));
         for (int i = 0; i < textureCount; ++i) {
-            const GrBackendTexture& backendTex = curImage.promiseTexture(i)->backendTexture();
-            backendFormats[i] = backendTex.getBackendFormat();
+            backendFormats[i] = curImage.backendFormat(i);
             SkASSERT(backendFormats[i].isValid());
             contexts[i] = curImage.refCallbackContext(i).release();
             sizes[i].set(curImage.yuvPixmap(i).width(), curImage.yuvPixmap(i).height());
@@ -198,8 +265,7 @@
         }
 #endif
     } else {
-        const GrBackendTexture& backendTex = curImage.promiseTexture(0)->backendTexture();
-        GrBackendFormat backendFormat = backendTex.getBackendFormat();
+        GrBackendFormat backendFormat = curImage.backendFormat(0);
         SkASSERT(backendFormat.isValid());
 
         // Each DDL recorder gets its own ref on the promise callback context for the
diff --git a/tools/DDLPromiseImageHelper.h b/tools/DDLPromiseImageHelper.h
index 99d883e..7fff09e 100644
--- a/tools/DDLPromiseImageHelper.h
+++ b/tools/DDLPromiseImageHelper.h
@@ -53,7 +53,9 @@
     // Convert the SkPicture into SkData replacing all the SkImages with an index.
     sk_sp<SkData> deflateSKP(const SkPicture* inputPicture);
 
-    void uploadAllToGPU(GrContext* context);
+    void createCallbackContexts(GrContext*);
+
+    void uploadAllToGPU(SkTaskGroup*, GrContext*);
 
     // reinflate a deflated SKP, replacing all the indices with promise images.
     sk_sp<SkPicture> reinflateSKP(SkDeferredDisplayListRecorder*,
@@ -73,10 +75,14 @@
     // it drops all of its refs (via "reset").
     class PromiseImageCallbackContext : public SkRefCnt {
     public:
-        PromiseImageCallbackContext(GrContext* context) : fContext(context) {}
+        PromiseImageCallbackContext(GrContext* context, GrBackendFormat backendFormat)
+                : fContext(context)
+                , fBackendFormat(backendFormat) {}
 
         ~PromiseImageCallbackContext();
 
+        const GrBackendFormat& backendFormat() const { return fBackendFormat; }
+
         void setBackendTexture(const GrBackendTexture& backendTexture);
 
         sk_sp<SkPromiseImageTexture> fulfill() {
@@ -101,17 +107,18 @@
         void wasAddedToImage() { fNumImages++; }
 
         const SkPromiseImageTexture* promiseImageTexture() const {
-          return fPromiseImageTexture.get();
+            return fPromiseImageTexture.get();
         }
 
     private:
-        GrContext* fContext;
+        GrContext*                   fContext;
+        GrBackendFormat              fBackendFormat;
         sk_sp<SkPromiseImageTexture> fPromiseImageTexture;
-        int fNumImages = 0;
-        int fTotalFulfills = 0;
-        int fTotalReleases = 0;
-        int fUnreleasedFulfills = 0;
-        int fDoneCnt = 0;
+        int                          fNumImages = 0;
+        int                          fTotalFulfills = 0;
+        int                          fTotalReleases = 0;
+        int                          fUnreleasedFulfills = 0;
+        int                          fDoneCnt = 0;
 
         typedef SkRefCnt INHERITED;
     };
@@ -169,6 +176,10 @@
             return fCallbackContexts[index];
         }
 
+        const GrBackendFormat& backendFormat(int index) const {
+            SkASSERT(index >= 0 && index < (this->isYUV() ? SkYUVASizeInfo::kMaxCount : 1));
+            return fCallbackContexts[index]->backendFormat();
+        }
         const SkPromiseImageTexture* promiseTexture(int index) const {
             SkASSERT(index >= 0 && index < (this->isYUV() ? SkYUVASizeInfo::kMaxCount : 1));
             return fCallbackContexts[index]->promiseImageTexture();
@@ -216,6 +227,8 @@
         SkTArray<sk_sp<SkImage>>*      fPromiseImages;
     };
 
+    static void CreateBETexturesForPromiseImage(GrContext*, PromiseImageInfo*);
+
     static sk_sp<SkPromiseImageTexture> PromiseImageFulfillProc(void* textureContext) {
         auto callbackContext = static_cast<PromiseImageCallbackContext*>(textureContext);
         return callbackContext->fulfill();
@@ -232,7 +245,7 @@
         callbackContext->unref();
     }
 
-    static sk_sp<SkImage> PromiseImageCreator(const void* rawData, size_t length, void* ctxIn);
+    static sk_sp<SkImage> CreatePromiseImages(const void* rawData, size_t length, void* ctxIn);
 
     bool isValidID(int id) const { return id >= 0 && id < fImageInfo.count(); }
     const PromiseImageInfo& getInfo(int id) const { return fImageInfo[id]; }
diff --git a/tools/skpbench/skpbench.cpp b/tools/skpbench/skpbench.cpp
index 1799bc6..31e01e3 100644
--- a/tools/skpbench/skpbench.cpp
+++ b/tools/skpbench/skpbench.cpp
@@ -238,7 +238,9 @@
         exitf(ExitErr::kUnavailable, "DDL: conversion of skp failed");
     }
 
-    promiseImageHelper.uploadAllToGPU(context);
+    promiseImageHelper.createCallbackContexts(context);
+
+    promiseImageHelper.uploadAllToGPU(nullptr, context);
 
     DDLTileHelper tiles(surface, viewport, FLAGS_ddlTilingWidthHeight);