diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h
index 6fad217..08e558c 100644
--- a/include/core/SkSurface.h
+++ b/include/core/SkSurface.h
@@ -341,15 +341,22 @@
      * signalSemaphores with the info on the semaphores we submitted. The client is reposonsible for
      * allocating enough space in signalSemaphores to handle numSemaphores of GrBackendSemaphores.
      * The client will also take ownership of the returned underlying backend semaphores.
+     *
+     * If this call returns false, the GPU backend will not have created or added any semaphores to
+     * signal. Thus the array of semaphores will remain uninitialized. However, we will still flush
+     * any pending surface IO.
      */
-    void flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores);
+    bool flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores);
 
     /**
      * Inserts a list of GPU semaphores that the current backend 3D API must wait on before
      * executing any more commands on the GPU for this surface. Skia will take ownership of the
      * underlying semaphores and delete them once they have been signaled and waited on.
+     *
+     * If this call returns false, then the GPU backend will not wait on any passed in semaphores,
+     * and the client will still own the semaphores.
      */
-    void wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
+    bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
 
 protected:
     SkSurface(int width, int height, const SkSurfaceProps*);
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 2a04b1e..56aac99 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1431,13 +1431,18 @@
     this->addLegacyMeshDrawOp(std::move(pipelineBuilder), clip, std::move(op));
 }
 
-void GrRenderTargetContext::prepareForExternalIO(int numSemaphores,
+bool GrRenderTargetContext::prepareForExternalIO(int numSemaphores,
                                                  GrBackendSemaphore* backendSemaphores) {
     ASSERT_SINGLE_OWNER
-    RETURN_IF_ABANDONED
+    RETURN_FALSE_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrRenderTargetContext::prepareForExternalIO");
 
+    if (numSemaphores && !this->caps()->fenceSyncSupport()) {
+        this->drawingManager()->prepareSurfaceForExternalIO(fRenderTargetProxy.get());
+        return false;
+    }
+
     SkTArray<sk_sp<GrSemaphore>> semaphores(numSemaphores);
     for (int i = 0; i < numSemaphores; ++i) {
         semaphores.push_back(fContext->resourceProvider()->makeSemaphore(false));
@@ -1451,17 +1456,22 @@
     for (int i = 0; i < numSemaphores; ++i) {
         semaphores[i]->setBackendSemaphore(&backendSemaphores[i]);
     }
+    return true;
 }
 
-void GrRenderTargetContext::waitOnSemaphores(int numSemaphores,
+bool GrRenderTargetContext::waitOnSemaphores(int numSemaphores,
                                              const GrBackendSemaphore* waitSemaphores) {
     ASSERT_SINGLE_OWNER
-    RETURN_IF_ABANDONED
+    RETURN_FALSE_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrRenderTargetContext::waitOnSemaphores");
 
     AutoCheckFlush acf(this->drawingManager());
 
+    if (numSemaphores && !this->caps()->fenceSyncSupport()) {
+        return false;
+    }
+
     SkTArray<sk_sp<GrSemaphore>> semaphores(numSemaphores);
     for (int i = 0; i < numSemaphores; ++i) {
         sk_sp<GrSemaphore> sema = fContext->resourceProvider()->wrapBackendSemaphore(
@@ -1469,6 +1479,7 @@
         std::unique_ptr<GrOp> waitOp(GrSemaphoreOp::MakeWait(sema, fRenderTargetProxy.get()));
         this->getOpList()->addOp(std::move(waitOp), *this->caps());
     }
+    return true;
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index a2369dd..8cb4432 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -303,13 +303,13 @@
      * After this returns any pending surface IO will be issued to the backend 3D API and
      * if the surface has MSAA it will be resolved.
      */
-    void prepareForExternalIO(int numSemaphores, GrBackendSemaphore* backendSemaphores);
+    bool prepareForExternalIO(int numSemaphores, GrBackendSemaphore* backendSemaphores);
 
     /**
      *  The next time this GrRenderTargetContext is flushed, the gpu will wait on the passed in
      *  semaphores before executing any commands.
      */
-    void waitOnSemaphores(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
+    bool waitOnSemaphores(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
 
     GrFSAAType fsaaType() const { return fRenderTargetProxy->fsaaType(); }
     const GrCaps* caps() const { return fContext->caps(); }
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index ee6e88d..301adc1 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1736,17 +1736,17 @@
     this->flushAndSignalSemaphores(0, nullptr);
 }
 
-void SkGpuDevice::flushAndSignalSemaphores(int numSemaphores,
+bool SkGpuDevice::flushAndSignalSemaphores(int numSemaphores,
                                            GrBackendSemaphore* signalSemaphores) {
     ASSERT_SINGLE_OWNER
 
-    fRenderTargetContext->prepareForExternalIO(numSemaphores, signalSemaphores);
+    return fRenderTargetContext->prepareForExternalIO(numSemaphores, signalSemaphores);
 }
 
-void SkGpuDevice::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
+bool SkGpuDevice::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
     ASSERT_SINGLE_OWNER
 
-    fRenderTargetContext->waitOnSemaphores(numSemaphores, waitSemaphores);
+    return fRenderTargetContext->waitOnSemaphores(numSemaphores, waitSemaphores);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/SkGpuDevice.h b/src/gpu/SkGpuDevice.h
index 317533d..b5133f4 100644
--- a/src/gpu/SkGpuDevice.h
+++ b/src/gpu/SkGpuDevice.h
@@ -118,8 +118,8 @@
     sk_sp<SkSpecialImage> snapSpecial() override;
 
     void flush() override;
-    void flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores);
-    void wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
+    bool flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores);
+    bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores);
 
     bool onAccessPixels(SkPixmap*) override;
 
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index d401600..e5e8841 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -4273,6 +4273,7 @@
 }
 
 GrFence SK_WARN_UNUSED_RESULT GrGLGpu::insertFence() {
+    SkASSERT(this->caps()->fenceSyncSupport());
     GrGLsync sync;
     GL_CALL_RET(sync, FenceSync(GR_GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
     GR_STATIC_ASSERT(sizeof(GrFence) >= sizeof(GrGLsync));
@@ -4290,11 +4291,13 @@
 }
 
 sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrGLGpu::makeSemaphore(bool isOwned) {
+    SkASSERT(this->caps()->fenceSyncSupport());
     return GrGLSemaphore::Make(this, isOwned);
 }
 
 sk_sp<GrSemaphore> GrGLGpu::wrapBackendSemaphore(const GrBackendSemaphore& semaphore,
                                                  GrWrapOwnership ownership) {
+    SkASSERT(this->caps()->fenceSyncSupport());
     return GrGLSemaphore::MakeWrapped(this, semaphore.glSync(), ownership);
 }
 
diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp
index fbd9f83..57d419c 100644
--- a/src/image/SkSurface.cpp
+++ b/src/image/SkSurface.cpp
@@ -191,12 +191,12 @@
     asSB(this)->onFlush(0, nullptr);
 }
 
-void SkSurface::flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
+bool SkSurface::flushAndSignalSemaphores(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
     return asSB(this)->onFlush(numSemaphores, signalSemaphores);
 }
 
-void SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
-    asSB(this)->onWait(numSemaphores, waitSemaphores);
+bool SkSurface::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
+    return asSB(this)->onWait(numSemaphores, waitSemaphores);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index 264a86f..93528b8 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -80,14 +80,18 @@
      * Inserts the requested number of semaphores for the gpu to signal when work is complete on the
      * gpu and inits the array of GrBackendSemaphores with the signaled semaphores.
      */
-    virtual void onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) {}
+    virtual bool onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
+        return false;
+    }
 
     /**
      * Caused the current backend 3D API to wait on the passed in semaphores before executing new
      * commands on the gpu. Any previously submitting commands will not be blocked by these
      * semaphores.
      */
-    virtual void onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {}
+    virtual bool onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
+        return false;
+    }
 
     inline SkCanvas* getCachedCanvas();
     inline sk_sp<SkImage> refCachedImage();
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index 0f4b2cb..13c89d4 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -166,12 +166,12 @@
     fDevice->accessRenderTargetContext()->discard();
 }
 
-void SkSurface_Gpu::onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
-    fDevice->flushAndSignalSemaphores(numSemaphores, signalSemaphores);
+bool SkSurface_Gpu::onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) {
+    return fDevice->flushAndSignalSemaphores(numSemaphores, signalSemaphores);
 }
 
-void SkSurface_Gpu::onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
-    fDevice->wait(numSemaphores, waitSemaphores);
+bool SkSurface_Gpu::onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
+    return fDevice->wait(numSemaphores, waitSemaphores);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/image/SkSurface_Gpu.h b/src/image/SkSurface_Gpu.h
index e22ae10..2bc9210 100644
--- a/src/image/SkSurface_Gpu.h
+++ b/src/image/SkSurface_Gpu.h
@@ -26,8 +26,8 @@
     sk_sp<SkImage> onNewImageSnapshot() override;
     void onCopyOnWrite(ContentChangeMode) override;
     void onDiscard() override;
-    void onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) override;
-    void onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) override;
+    bool onFlush(int numSemaphores, GrBackendSemaphore* signalSemaphores) override;
+    bool onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) override;
 
     SkGpuDevice* getDevice() { return fDevice.get(); }