diff --git a/src/gpu/GrBackendSurface.cpp b/src/gpu/GrBackendSurface.cpp
index 8b3e2f1..77a5617 100644
--- a/src/gpu/GrBackendSurface.cpp
+++ b/src/gpu/GrBackendSurface.cpp
@@ -10,6 +10,11 @@
 
 #include "src/gpu/gl/GrGLUtil.h"
 
+#ifdef SK_DAWN
+#include "include/gpu/dawn/GrDawnTypes.h"
+#include "src/gpu/dawn/GrDawnUtil.h"
+#endif
+
 #ifdef SK_VULKAN
 #include "include/gpu/vk/GrVkTypes.h"
 #include "src/gpu/vk/GrVkImageLayout.h"
@@ -44,6 +49,11 @@
             fMtlFormat = that.fMtlFormat;
             break;
 #endif
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn:
+            fDawnFormat = that.fDawnFormat;
+            break;
+#endif
         case GrBackendApi::kMock:
             fMockColorType = that.fMockColorType;
             break;
@@ -138,6 +148,22 @@
     return nullptr;
 }
 
+#ifdef SK_DAWN
+GrBackendFormat::GrBackendFormat(dawn::TextureFormat format)
+        : fBackend(GrBackendApi::kDawn)
+        , fValid(true)
+        , fDawnFormat(format)
+        , fTextureType(GrTextureType::k2D) {
+}
+
+const dawn::TextureFormat* GrBackendFormat::getDawnFormat() const {
+    if (this->isValid() && GrBackendApi::kDawn == fBackend) {
+        return &fDawnFormat;
+    }
+    return nullptr;
+}
+#endif
+
 #ifdef SK_METAL
 GrBackendFormat::GrBackendFormat(GrMTLPixelFormat mtlFormat)
         : fBackend(GrBackendApi::kMetal)
@@ -207,6 +233,11 @@
             return fMtlFormat == that.fMtlFormat;
 #endif
             break;
+        case GrBackendApi::kDawn:
+#ifdef SK_DAWN
+            return fDawnFormat == that.fDawnFormat;
+#endif
+            break;
         case GrBackendApi::kMock:
             return fMockColorType == that.fMockColorType;
         default:
@@ -215,6 +246,19 @@
     return false;
 }
 
+#ifdef SK_DAWN
+GrBackendTexture::GrBackendTexture(int width,
+                                   int height,
+                                   const GrDawnImageInfo& dawnInfo)
+        : fIsValid(true)
+        , fWidth(width)
+        , fHeight(height)
+        , fConfig(GrDawnFormatToPixelConfig(dawnInfo.fFormat))
+        , fMipMapped(GrMipMapped(dawnInfo.fLevelCount > 1))
+        , fBackend(GrBackendApi::kDawn)
+        , fDawnInfo(dawnInfo) {}
+#endif
+
 GrBackendTexture::GrBackendTexture(int width,
                                    int height,
                                    const GrVkImageInfo& vkInfo)
@@ -357,6 +401,11 @@
             fMtlInfo = that.fMtlInfo;
             break;
 #endif
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn:
+            fDawnInfo = that.fDawnInfo;
+            break;
+#endif
         case GrBackendApi::kMock:
             fMockInfo = that.fMockInfo;
             break;
@@ -367,6 +416,16 @@
     return *this;
 }
 
+#ifdef SK_DAWN
+bool GrBackendTexture::getDawnImageInfo(GrDawnImageInfo* outInfo) const {
+    if (this->isValid() && GrBackendApi::kDawn == fBackend) {
+        *outInfo = fDawnInfo;
+        return true;
+    }
+    return false;
+}
+#endif
+
 bool GrBackendTexture::getVkImageInfo(GrVkImageInfo* outInfo) const {
 #ifdef SK_VULKAN
     if (this->isValid() && GrBackendApi::kVulkan == fBackend) {
@@ -484,6 +543,11 @@
             return GrBackendFormat::MakeVk(info.fFormat);
         }
 #endif
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn: {
+            return GrBackendFormat::MakeDawn(fDawnInfo.fFormat);
+        }
+#endif
 #ifdef SK_METAL
         case GrBackendApi::kMetal: {
             GrMtlTextureInfo mtlInfo;
@@ -527,6 +591,10 @@
         case GrBackendApi::kMetal:
             return t0.fMtlInfo == t1.fMtlInfo;
 #endif
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn:
+            return t0.fDawnInfo == t1.fDawnInfo;
+#endif
         default:
             return false;
     }
@@ -535,6 +603,22 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef SK_DAWN
+GrBackendRenderTarget::GrBackendRenderTarget(int width,
+                                             int height,
+                                             int sampleCnt,
+                                             int stencilBits,
+                                             const GrDawnImageInfo& dawnInfo)
+        : fIsValid(true)
+        , fWidth(width)
+        , fHeight(height)
+        , fSampleCnt(sampleCnt)
+        , fStencilBits(stencilBits)
+        , fConfig(GrDawnFormatToPixelConfig(dawnInfo.fFormat))
+        , fBackend(GrBackendApi::kDawn)
+        , fDawnInfo(dawnInfo) {}
+#endif
+
 GrBackendRenderTarget::GrBackendRenderTarget(int width,
                                              int height,
                                              int sampleCnt,
@@ -670,6 +754,11 @@
             fVkInfo.assign(that.fVkInfo, this->isValid());
 #endif
             break;
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn:
+            fDawnInfo = that.fDawnInfo;
+            break;
+#endif
 #ifdef SK_METAL
         case GrBackendApi::kMetal:
             fMtlInfo = that.fMtlInfo;
@@ -685,6 +774,16 @@
     return *this;
 }
 
+#ifdef SK_DAWN
+bool GrBackendRenderTarget::getDawnImageInfo(GrDawnImageInfo* outInfo) const {
+    if (this->isValid() && GrBackendApi::kDawn == fBackend) {
+        *outInfo = fDawnInfo;
+        return true;
+    }
+    return false;
+}
+#endif
+
 bool GrBackendRenderTarget::getVkImageInfo(GrVkImageInfo* outInfo) const {
 #ifdef SK_VULKAN
     if (this->isValid() && GrBackendApi::kVulkan == fBackend) {
@@ -802,6 +901,10 @@
         case GrBackendApi::kMetal:
             return r0.fMtlInfo == r1.fMtlInfo;
 #endif
+#ifdef SK_DAWN
+        case GrBackendApi::kDawn:
+            return r0.fDawnInfo == r1.fDawnInfo;
+#endif
         default:
             return false;
     }
diff --git a/src/gpu/GrContextPriv.cpp b/src/gpu/GrContextPriv.cpp
index ad6d8ab..14795d2 100644
--- a/src/gpu/GrContextPriv.cpp
+++ b/src/gpu/GrContextPriv.cpp
@@ -231,14 +231,16 @@
 
     static const char* kBackendStr[] = {
         "Metal",
+        "Dawn",
         "OpenGL",
         "Vulkan",
         "Mock",
     };
     GR_STATIC_ASSERT(0 == (unsigned)GrBackendApi::kMetal);
-    GR_STATIC_ASSERT(1 == (unsigned)GrBackendApi::kOpenGL);
-    GR_STATIC_ASSERT(2 == (unsigned)GrBackendApi::kVulkan);
-    GR_STATIC_ASSERT(3 == (unsigned)GrBackendApi::kMock);
+    GR_STATIC_ASSERT(1 == (unsigned)GrBackendApi::kDawn);
+    GR_STATIC_ASSERT(2 == (unsigned)GrBackendApi::kOpenGL);
+    GR_STATIC_ASSERT(3 == (unsigned)GrBackendApi::kVulkan);
+    GR_STATIC_ASSERT(4 == (unsigned)GrBackendApi::kMock);
     writer.appendString("backend", kBackendStr[(unsigned)fContext->backend()]);
 
     writer.appendName("caps");
diff --git a/src/gpu/GrLegacyDirectContext.cpp b/src/gpu/GrLegacyDirectContext.cpp
index 4c3f756..b6bfd12 100644
--- a/src/gpu/GrLegacyDirectContext.cpp
+++ b/src/gpu/GrLegacyDirectContext.cpp
@@ -23,6 +23,9 @@
 #ifdef SK_VULKAN
 #include "src/gpu/vk/GrVkGpu.h"
 #endif
+#ifdef SK_DAWN
+#include "dawn/GrDawnGpu.h"
+#endif
 
 #ifdef SK_DISABLE_REDUCE_OPLIST_SPLITTING
 static const bool kDefaultReduceOpListSplitting = false;
@@ -218,3 +221,23 @@
 }
 #endif
 
+#ifdef SK_DAWN
+sk_sp<GrContext> GrContext::MakeDawn(const dawn::Device& device) {
+    GrContextOptions defaultOptions;
+    return MakeDawn(device, defaultOptions);
+}
+
+sk_sp<GrContext> GrContext::MakeDawn(const dawn::Device& device, const GrContextOptions& options) {
+    sk_sp<GrContext> context(new GrLegacyDirectContext(GrBackendApi::kDawn, options));
+
+    context->fGpu = GrDawnGpu::Make(device, options, context.get());
+    if (!context->fGpu) {
+        return nullptr;
+    }
+
+    if (!context->init(context->fGpu->refCaps(), nullptr)) {
+        return nullptr;
+    }
+    return context;
+}
+#endif
diff --git a/src/gpu/dawn/GrDawnCaps.cpp b/src/gpu/dawn/GrDawnCaps.cpp
new file mode 100644
index 0000000..3fb9a55
--- /dev/null
+++ b/src/gpu/dawn/GrDawnCaps.cpp
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDawnCaps.h"
+
+GrDawnCaps::GrDawnCaps(const GrContextOptions& contextOptions) : INHERITED(contextOptions) {
+    fBufferMapThreshold = SK_MaxS32;  // FIXME: get this from Dawn?
+    fShaderCaps.reset(new GrShaderCaps(contextOptions));
+    fMaxTextureSize = 2048;
+    fPerformPartialClearsAsDraws = true;
+}
+
+bool GrDawnCaps::isFormatSRGB(const GrBackendFormat& format) const {
+    return false;
+}
+
+bool GrDawnCaps::isConfigTexturable(GrPixelConfig config) const {
+    switch (config) {
+        case kRGBA_8888_GrPixelConfig:
+        case kBGRA_8888_GrPixelConfig:
+        case kAlpha_8_GrPixelConfig:
+            return true;
+        default:
+            return false;
+    }
+}
+
+GrPixelConfig GrDawnCaps::onGetConfigFromBackendFormat(const GrBackendFormat& format,
+                                                     GrColorType colorType) const {
+    dawn::TextureFormat textureFormat = *format.getDawnFormat();
+    switch (colorType) {
+        case GrColorType::kUnknown:
+            return kUnknown_GrPixelConfig;
+        case GrColorType::kAlpha_8:
+            if (dawn::TextureFormat::R8Unorm == textureFormat) {
+                return kAlpha_8_as_Red_GrPixelConfig;
+            }
+            break;
+        case GrColorType::kRGBA_8888:
+            if (dawn::TextureFormat::R8G8B8A8Unorm == textureFormat) {
+                return kRGBA_8888_GrPixelConfig;
+            }
+            break;
+        case GrColorType::kRGB_888x:
+            break;
+        case GrColorType::kBGRA_8888:
+            if (dawn::TextureFormat::B8G8R8A8Unorm == textureFormat) {
+                return kBGRA_8888_GrPixelConfig;
+            }
+            break;
+        default:
+            break;
+    }
+    return kUnknown_GrPixelConfig;
+}
+
+GrPixelConfig GrDawnCaps::getYUVAConfigFromBackendFormat(const GrBackendFormat& backendFormat)
+        const {
+    const dawn::TextureFormat* format = backendFormat.getDawnFormat();
+    if (!format) {
+        return kUnknown_GrPixelConfig;
+    }
+    switch (*format) {
+        case dawn::TextureFormat::R8Unorm:
+            return kAlpha_8_as_Red_GrPixelConfig;
+            break;
+        case dawn::TextureFormat::R8G8B8A8Unorm:
+            return kRGBA_8888_GrPixelConfig;
+            break;
+        case dawn::TextureFormat::B8G8R8A8Unorm:
+            return kBGRA_8888_GrPixelConfig;
+            break;
+        default:
+            return kUnknown_GrPixelConfig;
+            break;
+    }
+}
+
+size_t GrDawnCaps::onTransferFromOffsetAlignment(GrColorType bufferColorType) const {
+    if (bufferColorType == GrColorType::kRGB_888x) {
+        return false;
+    }
+    size_t bpp = GrColorTypeBytesPerPixel(bufferColorType);
+    switch (bpp & 0b11) {
+        case 0:     return bpp;
+        case 2:     return 2 * bpp;
+        default:    return 4 * bpp;
+    }
+}
+
+static GrSwizzle get_swizzle(const GrBackendFormat& format, GrColorType colorType,
+                             bool forOutput) {
+    SkASSERT(format.getDawnFormat());
+
+    switch (colorType) {
+        case GrColorType::kAlpha_8: // fall through
+        case GrColorType::kAlpha_F16:
+            if (forOutput) {
+                return GrSwizzle::AAAA();
+            } else {
+                return GrSwizzle::RRRR();
+            }
+        case GrColorType::kGray_8:
+            if (!forOutput) {
+                return GrSwizzle::RRRA();
+            }
+            break;
+        case GrColorType::kRGB_888x:
+            if (!forOutput) {
+                return GrSwizzle::RGB1();
+            }
+        default:
+            return GrSwizzle::RGBA();
+    }
+    return GrSwizzle::RGBA();
+}
+
+bool GrDawnCaps::isFormatTexturable(GrColorType ct, const GrBackendFormat& format) const {
+    GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+    if (kUnknown_GrPixelConfig == config) {
+        return false;
+    }
+
+    return this->isConfigTexturable(config);
+}
+
+bool GrDawnCaps::isFormatCopyable(GrColorType ct, const GrBackendFormat& format) const {
+    return true;
+}
+
+int GrDawnCaps::getRenderTargetSampleCount(int requestedCount, GrColorType ct,
+                                           const GrBackendFormat& format) const {
+    GrPixelConfig config = this->getConfigFromBackendFormat(format, ct);
+    if (kUnknown_GrPixelConfig == config) {
+        return 0;
+    }
+
+    return this->getRenderTargetSampleCount(requestedCount, config);
+}
+
+GrBackendFormat GrDawnCaps::getBackendFormatFromColorType(GrColorType ct) const {
+    GrPixelConfig config = GrColorTypeToPixelConfig(ct);
+    if (config == kUnknown_GrPixelConfig) {
+        return GrBackendFormat();
+    }
+    dawn::TextureFormat format;
+    if (!GrPixelConfigToDawnFormat(config, &format)) {
+        return GrBackendFormat();
+    }
+    return GrBackendFormat::MakeDawn(format);
+}
+
+GrBackendFormat GrDawnCaps::getBackendFormatFromCompressionType(SkImage::CompressionType type) const
+{
+    return GrBackendFormat();
+}
+
+GrSwizzle GrDawnCaps::getTextureSwizzle(const GrBackendFormat& format, GrColorType colorType) const
+{
+    return get_swizzle(format, colorType, false);
+}
+
+bool GrDawnCaps::canClearTextureOnCreation() const {
+    return true;
+}
+
+GrSwizzle GrDawnCaps::getOutputSwizzle(const GrBackendFormat& format, GrColorType colorType) const
+{
+    return get_swizzle(format, colorType, true);
+}
+
+bool GrDawnCaps::onAreColorTypeAndFormatCompatible(GrColorType ct,
+                                                   const GrBackendFormat& format) const {
+    return true;
+}
diff --git a/src/gpu/dawn/GrDawnCaps.h b/src/gpu/dawn/GrDawnCaps.h
new file mode 100644
index 0000000..a28eae0
--- /dev/null
+++ b/src/gpu/dawn/GrDawnCaps.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnCaps_DEFINED
+#define GrDawnCaps_DEFINED
+
+#include "src/gpu/GrCaps.h"
+#include "include/gpu/GrContextOptions.h"
+#include "src/gpu/dawn/GrDawnUtil.h"
+#include "include/gpu/GrBackendSurface.h"
+
+class GrDawnCaps : public GrCaps {
+public:
+    GrDawnCaps(const GrContextOptions& contextOptions);
+
+    bool isFormatSRGB(const GrBackendFormat& format) const override;
+    bool isFormatTexturable(GrColorType, const GrBackendFormat& format) const override;
+    bool isFormatCopyable(GrColorType, const GrBackendFormat& format) const override;
+
+    bool isConfigTexturable(GrPixelConfig config) const override;
+
+    bool isConfigCopyable(GrPixelConfig config) const override {
+        return true;
+    }
+
+    bool onCanCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
+                          const SkIRect& srcRect, const SkIPoint& dstPoint) const override {
+        return true;
+    }
+
+    bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc,
+                            bool* rectsMustMatch, bool* disallowSubrect) const override {
+        return false;
+    }
+
+    GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&, GrColorType) const
+                                                                                         override {
+        return GrPixelConfig::kUnknown_GrPixelConfig;
+    }
+
+    GrPixelConfig onGetConfigFromBackendFormat(const GrBackendFormat&, GrColorType) const override;
+
+    GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const override;
+
+    SurfaceReadPixelsSupport surfaceSupportsReadPixels(const GrSurface*) const override {
+        return SurfaceReadPixelsSupport::kSupported;
+    }
+
+    bool onSurfaceSupportsWritePixels(const GrSurface* surface) const override {
+        return true;
+    }
+
+    int getRenderTargetSampleCount(int requestedCount, GrColorType,
+                                   const GrBackendFormat&) const override;
+
+    int getRenderTargetSampleCount(int requestedCount, GrPixelConfig config) const override {
+        return this->isConfigTexturable(config) ? 1 : 0;
+    }
+
+    int maxRenderTargetSampleCount(GrColorType ct,
+                                   const GrBackendFormat& format) const override {
+        return this->maxRenderTargetSampleCount(this->getConfigFromBackendFormat(format, ct));
+    }
+
+    int maxRenderTargetSampleCount(GrPixelConfig config) const override {
+        return this->isConfigTexturable(config) ? 1 : 0;
+    }
+
+    GrBackendFormat getBackendFormatFromColorType(GrColorType ct) const override;
+
+    GrBackendFormat getBackendFormatFromCompressionType(SkImage::CompressionType) const override;
+
+    bool canClearTextureOnCreation() const override;
+
+    GrSwizzle getTextureSwizzle(const GrBackendFormat&, GrColorType) const override;
+
+    GrSwizzle getOutputSwizzle(const GrBackendFormat&, GrColorType) const override;
+
+    size_t onTransferFromOffsetAlignment(GrColorType bufferColorType) const override;
+
+    bool onAreColorTypeAndFormatCompatible(GrColorType, const GrBackendFormat&) const override;
+
+    typedef GrCaps INHERITED;
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnGpu.cpp b/src/gpu/dawn/GrDawnGpu.cpp
new file mode 100644
index 0000000..b3d4a97
--- /dev/null
+++ b/src/gpu/dawn/GrDawnGpu.cpp
@@ -0,0 +1,258 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDawnGpu.h"
+
+#include "include/gpu/GrBackendSemaphore.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrContextOptions.h"
+#include "src/gpu/GrGeometryProcessor.h"
+#include "src/gpu/GrGpuResourceCacheAccess.h"
+#include "src/gpu/GrMesh.h"
+#include "src/gpu/dawn/GrDawnCaps.h"
+#include "src/gpu/dawn/GrDawnRenderTarget.h"
+#include "src/gpu/dawn/GrDawnGpuCommandBuffer.h"
+#include "src/gpu/GrPipeline.h"
+#include "src/gpu/GrRenderTargetPriv.h"
+#include "src/gpu/GrSemaphore.h"
+#include "src/gpu/GrTexturePriv.h"
+
+#include "src/sksl/SkSLCompiler.h"
+
+#if !defined(SK_BUILD_FOR_WIN)
+#include <unistd.h>
+#endif // !defined(SK_BUILD_FOR_WIN)
+
+sk_sp<GrGpu> GrDawnGpu::Make(const dawn::Device& device,
+                             const GrContextOptions& options, GrContext* context) {
+    if (!device) {
+        return nullptr;
+    }
+
+    return sk_sp<GrGpu>(new GrDawnGpu(context, options, device));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrDawnGpu::GrDawnGpu(GrContext* context, const GrContextOptions& options,
+                   const dawn::Device& device)
+        : INHERITED(context)
+        , fDevice(device)
+        , fQueue(device.CreateQueue())
+        , fCompiler(new SkSL::Compiler()) {
+    fCaps.reset(new GrDawnCaps(options));
+}
+
+GrDawnGpu::~GrDawnGpu() {
+}
+
+
+void GrDawnGpu::disconnect(DisconnectType type) {
+    INHERITED::disconnect(type);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrGpuRTCommandBuffer* GrDawnGpu::getCommandBuffer(
+            GrRenderTarget* rt, GrSurfaceOrigin origin, const SkRect& bounds,
+            const GrGpuRTCommandBuffer::LoadAndStoreInfo& colorInfo,
+            const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo& stencilInfo) {
+    fCachedRTCommandBuffer.reset(
+        new GrDawnGpuRTCommandBuffer(this, rt, origin, colorInfo, stencilInfo));
+    return fCachedRTCommandBuffer.get();
+}
+
+GrGpuTextureCommandBuffer* GrDawnGpu::getCommandBuffer(GrTexture* texture,
+                                                       GrSurfaceOrigin origin) {
+    return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+sk_sp<GrGpuBuffer> GrDawnGpu::onCreateBuffer(size_t size, GrGpuBufferType type,
+                                             GrAccessPattern accessPattern, const void* data) {
+    return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool GrDawnGpu::onWritePixels(GrSurface* surface,
+                              int left, int top, int width, int height,
+                              GrColorType colorType,
+                              const GrMipLevel texels[], int mipLevelCount) {
+    return false;
+}
+
+bool GrDawnGpu::onTransferPixelsTo(GrTexture* texture,
+                                  int left, int top, int width, int height,
+                                  GrColorType colorType, GrGpuBuffer* transferBuffer,
+                                  size_t bufferOffset, size_t rowBytes) {
+    return false;
+}
+
+bool GrDawnGpu::onTransferPixelsFrom(GrSurface* surface, int left, int top, int width, int height,
+                                     GrColorType, GrGpuBuffer* transferBuffer, size_t offset) {
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+sk_sp<GrTexture> GrDawnGpu::onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+                                            const GrMipLevel texels[], int mipLevelCount) {
+    return nullptr;
+}
+
+sk_sp<GrTexture> GrDawnGpu::onCreateCompressedTexture(int width, int height,
+                                                      SkImage::CompressionType, SkBudgeted,
+                                                      const void* data) {
+    return nullptr;
+}
+
+sk_sp<GrTexture> GrDawnGpu::onWrapBackendTexture(const GrBackendTexture& backendTex,
+                                                 GrWrapOwnership ownership,
+                                                 GrWrapCacheable cacheable,
+                                                 GrIOType) {
+    return nullptr;
+}
+
+sk_sp<GrTexture> GrDawnGpu::onWrapRenderableBackendTexture(const GrBackendTexture& tex,
+                                                           int sampleCnt, GrColorType,
+                                                           GrWrapOwnership,
+                                                           GrWrapCacheable cacheable) {
+    return nullptr;
+}
+
+sk_sp<GrRenderTarget> GrDawnGpu::onWrapBackendRenderTarget(const GrBackendRenderTarget&) {
+    return nullptr;
+}
+
+sk_sp<GrRenderTarget> GrDawnGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTexture& tex,
+                                                                    int sampleCnt) {
+    GrDawnImageInfo info;
+    if (!tex.getDawnImageInfo(&info)) {
+        return nullptr;
+    }
+    if (!info.fTexture) {
+        return nullptr;
+    }
+
+    GrSurfaceDesc desc;
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;
+    desc.fWidth = tex.width();
+    desc.fHeight = tex.height();
+    desc.fConfig = tex.config();
+    desc.fSampleCnt = this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config());
+    if (desc.fSampleCnt < 1) {
+        return nullptr;
+    }
+
+    sk_sp<GrDawnRenderTarget> tgt = GrDawnRenderTarget::MakeWrapped(this, desc, info);
+    return tgt;
+}
+
+GrStencilAttachment* GrDawnGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
+                                                                       int width,
+                                                                       int height,
+                                                                       int numStencilSamples) {
+    return nullptr;
+}
+
+GrBackendTexture GrDawnGpu::createBackendTexture(int width, int height,
+                                                 const GrBackendFormat& format,
+                                                 GrMipMapped mipMapped,
+                                                 GrRenderable renderable,
+                                                 const void* pixels,
+                                                 size_t rowBytes,
+                                                 const SkColor4f* color,
+                                                 GrProtected isProtected) {
+    return GrBackendTexture();
+}
+
+void GrDawnGpu::deleteBackendTexture(const GrBackendTexture& tex) {
+}
+
+#if GR_TEST_UTILS
+bool GrDawnGpu::isTestingOnlyBackendTexture(const GrBackendTexture& tex) const {
+    return false;
+}
+
+GrBackendRenderTarget GrDawnGpu::createTestingOnlyBackendRenderTarget(int w, int h, GrColorType) {
+    return GrBackendRenderTarget();
+}
+
+void GrDawnGpu::deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget&) {
+}
+
+void GrDawnGpu::testingOnly_flushGpuAndSync() {
+}
+
+#endif
+
+void GrDawnGpu::onFinishFlush(GrSurfaceProxy*[], int n, SkSurface::BackendSurfaceAccess access,
+                              const GrFlushInfo& info, const GrPrepareForExternalIORequests&) {
+}
+
+bool GrDawnGpu::onCopySurface(GrSurface* dst,
+                              GrSurface* src,
+                              const SkIRect& srcRect,
+                              const SkIPoint& dstPoint,
+                              bool canDiscardOutsideDstRect) {
+    return false;
+}
+
+bool GrDawnGpu::onReadPixels(GrSurface* surface,
+                             int left, int top, int width, int height,
+                             GrColorType colorType,
+                             void* buffer,
+                             size_t rowBytes) {
+    return false;
+}
+
+bool GrDawnGpu::onRegenerateMipMapLevels(GrTexture*) {
+    return false;
+}
+
+void GrDawnGpu::submit(GrGpuCommandBuffer* buffer) {
+    if (auto buf = static_cast<GrDawnGpuRTCommandBuffer*>(buffer->asRTCommandBuffer())) {
+        buf->submit();
+    }
+}
+
+GrFence SK_WARN_UNUSED_RESULT GrDawnGpu::insertFence() {
+    return GrFence();
+}
+
+bool GrDawnGpu::waitFence(GrFence fence, uint64_t timeout) {
+    return false;
+}
+
+void GrDawnGpu::deleteFence(GrFence fence) const {
+}
+
+sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrDawnGpu::makeSemaphore(bool isOwned) {
+    return nullptr;
+}
+
+sk_sp<GrSemaphore> GrDawnGpu::wrapBackendSemaphore(const GrBackendSemaphore& semaphore,
+                                                   GrResourceProvider::SemaphoreWrapType wrapType,
+                                                   GrWrapOwnership ownership) {
+    SkASSERT(!"unimplemented");
+    return nullptr;
+}
+
+void GrDawnGpu::insertSemaphore(sk_sp<GrSemaphore> semaphore) {
+    SkASSERT(!"unimplemented");
+}
+
+void GrDawnGpu::waitSemaphore(sk_sp<GrSemaphore> semaphore) {
+    SkASSERT(!"unimplemented");
+}
+
+void GrDawnGpu::checkFinishProcs() {
+    SkASSERT(!"unimplemented");
+}
+
+sk_sp<GrSemaphore> GrDawnGpu::prepareTextureForCrossContextUsage(GrTexture* texture) {
+    return nullptr;
+}
diff --git a/src/gpu/dawn/GrDawnGpu.h b/src/gpu/dawn/GrDawnGpu.h
new file mode 100644
index 0000000..e3c428f
--- /dev/null
+++ b/src/gpu/dawn/GrDawnGpu.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnGpu_DEFINED
+#define GrDawnGpu_DEFINED
+
+#include "src/gpu/GrGpu.h"
+#include "dawn/dawncpp.h"
+
+class GrPipeline;
+class GrDawnGpuRTCommandBuffer;
+
+namespace SkSL {
+    class Compiler;
+}
+
+class GrDawnGpu : public GrGpu {
+public:
+    static sk_sp<GrGpu> Make(const dawn::Device& device, const GrContextOptions&, GrContext*);
+    GrDawnGpu(GrContext* context, const GrContextOptions& options, const dawn::Device& device);
+
+    ~GrDawnGpu() override;
+
+    void disconnect(DisconnectType) override;
+
+    const dawn::Device& device() const { return fDevice; }
+    const dawn::Queue&  queue() const { return fQueue; }
+
+    void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
+
+    GrBackendTexture createBackendTexture(int w, int h,
+                                          const GrBackendFormat &,
+                                          GrMipMapped,
+                                          GrRenderable,
+                                          const void* pixels,
+                                          size_t rowBytes,
+                                          const SkColor4f* color,
+                                          GrProtected isProtected) override;
+    void deleteBackendTexture(const GrBackendTexture&) override;
+#if GR_TEST_UTILS
+    bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override;
+
+    GrBackendRenderTarget createTestingOnlyBackendRenderTarget(int w, int h, GrColorType) override;
+    void deleteTestingOnlyBackendRenderTarget(const GrBackendRenderTarget&) override;
+
+    void testingOnly_flushGpuAndSync() override;
+#endif
+
+    GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
+                                                                int width,
+                                                                int height,
+                                                                int numStencilSamples) override;
+
+    GrGpuRTCommandBuffer* getCommandBuffer(
+            GrRenderTarget*, GrSurfaceOrigin, const SkRect& bounds,
+            const GrGpuRTCommandBuffer::LoadAndStoreInfo&,
+            const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo&) override;
+
+    GrGpuTextureCommandBuffer* getCommandBuffer(GrTexture*, GrSurfaceOrigin) override;
+
+    SkSL::Compiler* shaderCompiler() const {
+        return fCompiler.get();
+    }
+
+    void submit(GrGpuCommandBuffer* cb) override;
+    GrFence SK_WARN_UNUSED_RESULT insertFence() override;
+    bool waitFence(GrFence, uint64_t timeout) override;
+    void deleteFence(GrFence) const override;
+
+    sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore(bool isOwned = true) override;
+    sk_sp<GrSemaphore> wrapBackendSemaphore(const GrBackendSemaphore& semaphore,
+                                            GrResourceProvider::SemaphoreWrapType wrapType,
+                                            GrWrapOwnership ownership) override;
+    void insertSemaphore(sk_sp<GrSemaphore> semaphore) override;
+    void waitSemaphore(sk_sp<GrSemaphore> semaphore) override;
+    void checkFinishProcs() override;
+
+    sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override;
+
+private:
+    void onResetContext(uint32_t resetBits) override {}
+
+    virtual void querySampleLocations(GrRenderTarget*, SkTArray<SkPoint>*) override {}
+
+    sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
+                                     const GrMipLevel texels[], int mipLevelCount) override;
+
+    sk_sp<GrTexture> onCreateCompressedTexture(int width, int height, SkImage::CompressionType,
+                                               SkBudgeted, const void* data) override;
+
+    sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+                                          GrWrapCacheable, GrIOType) override;
+    sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                    GrColorType, GrWrapOwnership,
+                                                    GrWrapCacheable) override;
+    sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override;
+
+    sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
+                                                             int sampleCnt) override;
+
+    sk_sp<GrGpuBuffer> onCreateBuffer(size_t size, GrGpuBufferType type, GrAccessPattern,
+                                      const void* data) override;
+
+    bool onReadPixels(GrSurface* surface,
+                      int left, int top, int width, int height,
+                      GrColorType, void* buffer, size_t rowBytes) override;
+
+    bool onWritePixels(GrSurface* surface,
+                       int left, int top, int width, int height,
+                       GrColorType, const GrMipLevel texels[], int mipLevelCount) override;
+
+    bool onTransferPixelsTo(GrTexture*, int left, int top, int width, int height,
+                            GrColorType colorType, GrGpuBuffer* transferBuffer,
+                            size_t offset, size_t rowBytes) override;
+
+    bool onTransferPixelsFrom(GrSurface* surface, int left, int top, int width, int height,
+                              GrColorType, GrGpuBuffer* transferBuffer, size_t offset) override;
+
+    void onResolveRenderTarget(GrRenderTarget* target) override {
+    }
+
+    bool onRegenerateMipMapLevels(GrTexture*) override;
+
+    bool onCopySurface(GrSurface* dst, GrSurface* src,
+                       const SkIRect& srcRect, const SkIPoint& dstPoint,
+                       bool canDiscardOutsideDstRect) override;
+
+    void onFinishFlush(GrSurfaceProxy*[], int n, SkSurface::BackendSurfaceAccess access,
+                       const GrFlushInfo& info, const GrPrepareForExternalIORequests&) override;
+
+    dawn::Device                                 fDevice;
+    dawn::Queue                                  fQueue;    // Must be Graphics queue
+
+    // Compiler used for compiling sksl into spirv. We only want to create the compiler once since
+    // there is significant overhead to the first compile of any compiler.
+    std::unique_ptr<SkSL::Compiler> fCompiler;
+
+    std::unique_ptr<GrDawnGpuRTCommandBuffer> fCachedRTCommandBuffer;
+
+    typedef GrGpu INHERITED;
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnGpuCommandBuffer.cpp b/src/gpu/dawn/GrDawnGpuCommandBuffer.cpp
new file mode 100644
index 0000000..39e3169
--- /dev/null
+++ b/src/gpu/dawn/GrDawnGpuCommandBuffer.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDawnGpuCommandBuffer.h"
+
+#include "src/gpu/GrFixedClip.h"
+#include "src/gpu/GrMesh.h"
+#include "src/gpu/GrOpFlushState.h"
+#include "src/gpu/GrPipeline.h"
+#include "src/gpu/GrRenderTargetPriv.h"
+#include "src/gpu/GrTexturePriv.h"
+#include "src/gpu/dawn/GrDawnGpu.h"
+#include "src/gpu/dawn/GrDawnRenderTarget.h"
+#include "include/core/SkRect.h"
+
+void GrDawnGpuTextureCommandBuffer::copy(GrSurface* src, const SkIRect& srcRect,
+                                         const SkIPoint& dstPoint) {
+}
+
+void GrDawnGpuTextureCommandBuffer::insertEventMarker(const char* msg) {
+}
+
+void GrDawnGpuTextureCommandBuffer::submit() {
+    for (int i = 0; i < fCopies.count(); ++i) {
+        CopyInfo& copyInfo = fCopies[i];
+        fGpu->copySurface(fTexture, copyInfo.fSrc, copyInfo.fSrcRect, copyInfo.fDstPoint);
+    }
+}
+
+GrDawnGpuTextureCommandBuffer::~GrDawnGpuTextureCommandBuffer() {}
+
+////////////////////////////////////////////////////////////////////////////////
+
+dawn::LoadOp to_dawn_load_op(GrLoadOp loadOp) {
+    switch (loadOp) {
+        case GrLoadOp::kLoad:
+            return dawn::LoadOp::Load;
+        case GrLoadOp::kClear:
+            return dawn::LoadOp::Clear;
+        case GrLoadOp::kDiscard:
+        default:
+            SK_ABORT("Invalid LoadOp");
+            return dawn::LoadOp::Load;
+    }
+}
+
+GrDawnGpuRTCommandBuffer::GrDawnGpuRTCommandBuffer(GrDawnGpu* gpu,
+                                                   GrRenderTarget* rt, GrSurfaceOrigin origin,
+                                                   const LoadAndStoreInfo& colorInfo,
+                                                   const StencilLoadAndStoreInfo& stencilInfo)
+        : INHERITED(rt, origin)
+        , fGpu(gpu) {
+    this->init();
+}
+
+void GrDawnGpuRTCommandBuffer::init() {
+}
+
+
+GrDawnGpuRTCommandBuffer::~GrDawnGpuRTCommandBuffer() {
+}
+
+GrGpu* GrDawnGpuRTCommandBuffer::gpu() { return fGpu; }
+
+void GrDawnGpuRTCommandBuffer::end() {
+}
+
+void GrDawnGpuRTCommandBuffer::submit() {
+    if (fCommandBuffer) {
+        fGpu->queue().Submit(1, &fCommandBuffer);
+    }
+}
+
+void GrDawnGpuRTCommandBuffer::insertEventMarker(const char* msg) {
+}
+
+void GrDawnGpuRTCommandBuffer::transferFrom(const SkIRect& srcRect, GrColorType bufferColorType,
+                                            GrGpuBuffer* transferBuffer, size_t offset) {
+    fGpu->transferPixelsFrom(fRenderTarget, srcRect.fLeft, srcRect.fTop, srcRect.width(),
+                             srcRect.height(), bufferColorType, transferBuffer, offset);
+}
+
+void GrDawnGpuRTCommandBuffer::onClearStencilClip(const GrFixedClip& clip, bool insideStencilMask) {
+}
+
+void GrDawnGpuRTCommandBuffer::onClear(const GrFixedClip& clip, const SkPMColor4f& color) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrDawnGpuRTCommandBuffer::inlineUpload(GrOpFlushState* state,
+                                            GrDeferredTextureUploadFn& upload) {
+}
+
+void GrDawnGpuRTCommandBuffer::copy(GrSurface* src, const SkIRect& srcRect,
+                                    const SkIPoint& dstPoint) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrDawnGpuRTCommandBuffer::bindGeometry(const GrBuffer* indexBuffer,
+                                            const GrBuffer* vertexBuffer,
+                                            const GrBuffer* instanceBuffer) {
+}
+
+void GrDawnGpuRTCommandBuffer::onDraw(const GrPrimitiveProcessor& primProc,
+                                      const GrPipeline& pipeline,
+                                      const GrPipeline::FixedDynamicState* fixedDynamicState,
+                                      const GrPipeline::DynamicStateArrays* dynamicStateArrays,
+                                      const GrMesh meshes[],
+                                      int meshCount,
+                                      const SkRect& bounds) {
+    if (!meshCount) {
+        return;
+    }
+    GrFragmentProcessor::Iter iter(pipeline);
+
+    for (int i = 0; i < meshCount; ++i) {
+        const GrMesh& mesh = meshes[i];
+        mesh.sendToGpu(this);
+    }
+}
+
+void GrDawnGpuRTCommandBuffer::sendInstancedMeshToGpu(GrPrimitiveType,
+                                                      const GrBuffer* vertexBuffer,
+                                                      int vertexCount,
+                                                      int baseVertex,
+                                                      const GrBuffer* instanceBuffer,
+                                                      int instanceCount,
+                                                      int baseInstance) {
+    this->bindGeometry(nullptr, vertexBuffer, instanceBuffer);
+    fGpu->stats()->incNumDraws();
+}
+
+void GrDawnGpuRTCommandBuffer::sendIndexedInstancedMeshToGpu(GrPrimitiveType,
+                                                             const GrBuffer* indexBuffer,
+                                                             int indexCount,
+                                                             int baseIndex,
+                                                             const GrBuffer* vertexBuffer,
+                                                             int baseVertex,
+                                                             const GrBuffer* instanceBuffer,
+                                                             int instanceCount,
+                                                             int baseInstance,
+                                                             GrPrimitiveRestart restart) {
+    this->bindGeometry(indexBuffer, vertexBuffer, instanceBuffer);
+    fGpu->stats()->incNumDraws();
+}
+
diff --git a/src/gpu/dawn/GrDawnGpuCommandBuffer.h b/src/gpu/dawn/GrDawnGpuCommandBuffer.h
new file mode 100644
index 0000000..4a6fd46
--- /dev/null
+++ b/src/gpu/dawn/GrDawnGpuCommandBuffer.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnGpuCommandBuffer_DEFINED
+#define GrDawnGpuCommandBuffer_DEFINED
+
+#include "src/gpu/GrGpuCommandBuffer.h"
+
+#include "src/gpu/GrColor.h"
+#include "src/gpu/GrMesh.h"
+#include "include/gpu/GrTypes.h"
+#include "dawn/dawncpp.h"
+
+class GrDawnGpu;
+class GrDawnRenderTarget;
+
+class GrDawnGpuTextureCommandBuffer : public GrGpuTextureCommandBuffer {
+public:
+    GrDawnGpuTextureCommandBuffer(GrDawnGpu* gpu, GrTexture* texture, GrSurfaceOrigin origin)
+        : INHERITED(texture, origin)
+        , fGpu(gpu) {
+    }
+
+    ~GrDawnGpuTextureCommandBuffer() override;
+
+    void copy(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) override;
+
+    void insertEventMarker(const char*) override;
+
+private:
+    void submit();
+
+    struct CopyInfo {
+        CopyInfo(GrSurface* src, GrSurfaceOrigin srcOrigin, const SkIRect& srcRect,
+                 const SkIPoint& dstPoint)
+            : fSrc(src), fSrcOrigin(srcOrigin), fSrcRect(srcRect), fDstPoint(dstPoint) {}
+
+        GrSurface*      fSrc;
+        GrSurfaceOrigin fSrcOrigin;
+        SkIRect         fSrcRect;
+        SkIPoint        fDstPoint;
+    };
+
+    GrDawnGpu*                   fGpu;
+    SkTArray<CopyInfo>          fCopies;
+
+    typedef GrGpuTextureCommandBuffer INHERITED;
+};
+
+class GrDawnGpuRTCommandBuffer : public GrGpuRTCommandBuffer, private GrMesh::SendToGpuImpl {
+public:
+    GrDawnGpuRTCommandBuffer(GrDawnGpu*, GrRenderTarget*, GrSurfaceOrigin,
+                             const LoadAndStoreInfo&,
+                             const StencilLoadAndStoreInfo&);
+
+    ~GrDawnGpuRTCommandBuffer() override;
+
+    void begin() override { }
+    void end() override;
+
+    void transferFrom(const SkIRect& srcRect, GrColorType bufferColorType,
+                      GrGpuBuffer* transferBuffer, size_t offset) override;
+    void insertEventMarker(const char*) override;
+
+    void inlineUpload(GrOpFlushState* state, GrDeferredTextureUploadFn& upload) override;
+
+    void copy(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) override;
+
+    void submit();
+
+private:
+    void init();
+
+    GrGpu* gpu() override;
+
+    // Bind vertex and index buffers
+    void bindGeometry(const GrBuffer* indexBuffer,
+                      const GrBuffer* vertexBuffer,
+                      const GrBuffer* instanceBuffer);
+
+    void onDraw(const GrPrimitiveProcessor& primProc,
+                const GrPipeline& pipeline,
+                const GrPipeline::FixedDynamicState* fixedDynamicState,
+                const GrPipeline::DynamicStateArrays* dynamicStateArrays,
+                const GrMesh mesh[],
+                int meshCount,
+                const SkRect& bounds) override;
+
+    void sendMeshToGpu(GrPrimitiveType primType, const GrBuffer* vertexBuffer, int vertexCount,
+                       int baseVertex) final {
+        this->sendInstancedMeshToGpu(primType, vertexBuffer, vertexCount, baseVertex,
+                                     nullptr, 1, 0);
+    }
+
+    void sendIndexedMeshToGpu(GrPrimitiveType primType,
+                              const GrBuffer* indexBuffer, int indexCount, int baseIndex,
+                              uint16_t /*minIndexValue*/, uint16_t /*maxIndexValue*/,
+                              const GrBuffer* vertexBuffer, int baseVertex,
+                              GrPrimitiveRestart restart) final {
+        this->sendIndexedInstancedMeshToGpu(primType, indexBuffer, indexCount, baseIndex,
+                                            vertexBuffer, baseVertex, nullptr, 1, 0, restart);
+    }
+
+    void sendInstancedMeshToGpu(GrPrimitiveType,
+                                const GrBuffer* vertexBuffer, int vertexCount, int baseVertex,
+                                const GrBuffer* instanceBuffer, int instanceCount,
+                                int baseInstance) final;
+
+    void sendIndexedInstancedMeshToGpu(GrPrimitiveType,
+                                       const GrBuffer* indexBuffer, int indexCount, int baseIndex,
+                                       const GrBuffer* vertexBuffer, int baseVertex,
+                                       const GrBuffer* instanceBuffer, int instanceCount,
+                                       int baseInstance, GrPrimitiveRestart) final;
+
+    void onClear(const GrFixedClip&, const SkPMColor4f& color) override;
+
+    void onClearStencilClip(const GrFixedClip&, bool insideStencilMask) override;
+
+    struct InlineUploadInfo {
+        InlineUploadInfo(GrOpFlushState* state, const GrDeferredTextureUploadFn& upload)
+                : fFlushState(state), fUpload(upload) {}
+
+        GrOpFlushState* fFlushState;
+        GrDeferredTextureUploadFn fUpload;
+    };
+
+    struct CopyInfo {
+        CopyInfo(GrSurface* src, GrSurfaceOrigin srcOrigin, const SkIRect& srcRect,
+                 const SkIPoint& dstPoint)
+            : fSrc(src), fSrcOrigin(srcOrigin), fSrcRect(srcRect), fDstPoint(dstPoint) {}
+
+        GrSurface*      fSrc;
+        GrSurfaceOrigin fSrcOrigin;
+        SkIRect         fSrcRect;
+        SkIPoint        fDstPoint;
+    };
+
+    dawn::CommandBuffer         fCommandBuffer;
+    GrDawnGpu*                  fGpu;
+
+    typedef GrGpuRTCommandBuffer INHERITED;
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnRenderTarget.cpp b/src/gpu/dawn/GrDawnRenderTarget.cpp
new file mode 100644
index 0000000..02b8a5b
--- /dev/null
+++ b/src/gpu/dawn/GrDawnRenderTarget.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDawnRenderTarget.h"
+
+#include "include/gpu/GrBackendSurface.h"
+#include "src/gpu/dawn/GrDawnGpu.h"
+#include "src/gpu/dawn/GrDawnUtil.h"
+
+GrDawnRenderTarget::GrDawnRenderTarget(GrDawnGpu* gpu,
+                                       const GrSurfaceDesc& desc,
+                                       const GrDawnImageInfo& info,
+                                       GrBackendObjectOwnership ownership)
+    : GrSurface(gpu, desc)
+    , GrRenderTarget(gpu, desc)
+    , fInfo(info) {
+    this->registerWithCacheWrapped(GrWrapCacheable::kNo);
+}
+
+GrDawnRenderTarget*
+GrDawnRenderTarget::Create(GrDawnGpu* gpu,
+                           const GrSurfaceDesc& desc,
+                           const GrDawnImageInfo& info,
+                           GrBackendObjectOwnership ownership) {
+    SkASSERT(1 == info.fLevelCount);
+    return new GrDawnRenderTarget(gpu, desc, info, ownership);
+}
+
+sk_sp<GrDawnRenderTarget>
+GrDawnRenderTarget::MakeWrapped(GrDawnGpu* gpu,
+                                const GrSurfaceDesc& desc,
+                                const GrDawnImageInfo& info) {
+    return sk_sp<GrDawnRenderTarget>(
+        GrDawnRenderTarget::Create(gpu, desc, info,
+                                  GrBackendObjectOwnership::kBorrowed));
+}
+
+bool GrDawnRenderTarget::completeStencilAttachment() {
+    return true;
+}
+
+GrDawnRenderTarget::~GrDawnRenderTarget() {
+}
+
+void GrDawnRenderTarget::onRelease() {
+    INHERITED::onRelease();
+}
+
+void GrDawnRenderTarget::onAbandon() {
+    INHERITED::onAbandon();
+}
+
+GrBackendRenderTarget GrDawnRenderTarget::getBackendRenderTarget() const {
+    return GrBackendRenderTarget(this->width(), this->height(), this->numSamples(),
+                                 this->numSamples(), fInfo);
+}
+
+GrBackendFormat GrDawnRenderTarget::backendFormat() const {
+    return GrBackendFormat::MakeDawn(fInfo.fFormat);
+}
diff --git a/src/gpu/dawn/GrDawnRenderTarget.h b/src/gpu/dawn/GrDawnRenderTarget.h
new file mode 100644
index 0000000..271eff0
--- /dev/null
+++ b/src/gpu/dawn/GrDawnRenderTarget.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#ifndef GrDawnRenderTarget_DEFINED
+#define GrDawnRenderTarget_DEFINED
+
+#include "include/gpu/dawn/GrDawnTypes.h"
+#include "include/gpu/GrRenderTarget.h"
+
+class GrDawnGpu;
+
+class GrDawnRenderTarget: public GrRenderTarget {
+public:
+    static sk_sp<GrDawnRenderTarget> MakeWrapped(GrDawnGpu*, const GrSurfaceDesc&,
+                                                 const GrDawnImageInfo&);
+
+    ~GrDawnRenderTarget() override;
+
+    // override of GrRenderTarget
+    ResolveType getResolveType() const override {
+        if (this->numSamples() > 1) {
+            return kCanResolve_ResolveType;
+        }
+        return kAutoResolves_ResolveType;
+    }
+
+    bool canAttemptStencilAttachment() const override {
+        return true;
+    }
+
+    GrBackendRenderTarget getBackendRenderTarget() const override;
+    GrBackendFormat backendFormat() const override;
+
+protected:
+    GrDawnRenderTarget(GrDawnGpu* gpu,
+                       const GrSurfaceDesc& desc,
+                       const GrDawnImageInfo& info,
+                       GrBackendObjectOwnership);
+
+    GrDawnGpu* getDawnGpu() const;
+
+    void onAbandon() override;
+    void onRelease() override;
+    void onSetRelease(sk_sp<GrRefCntedCallback> releaseHelper) override {}
+
+    // This accounts for the texture's memory and any MSAA renderbuffer's memory.
+    size_t onGpuMemorySize() const override {
+        // The plus 1 is to account for the resolve texture or if not using msaa the RT itself
+        int numSamples = this->numSamples() + 1;
+        return GrSurface::ComputeSize(this->config(), this->width(), this->height(),
+                                      numSamples, GrMipMapped::kNo);
+    }
+
+    static GrDawnRenderTarget* Create(GrDawnGpu*, const GrSurfaceDesc&,
+                                      const GrDawnImageInfo&, GrBackendObjectOwnership);
+
+    bool completeStencilAttachment() override;
+    GrDawnImageInfo fInfo;
+    typedef GrRenderTarget INHERITED;
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnUtil.cpp b/src/gpu/dawn/GrDawnUtil.cpp
new file mode 100644
index 0000000..fbb7b43
--- /dev/null
+++ b/src/gpu/dawn/GrDawnUtil.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDawnUtil.h"
+
+GrPixelConfig GrDawnFormatToPixelConfig(dawn::TextureFormat format) {
+    switch (format) {
+        case dawn::TextureFormat::R8G8B8A8Unorm:
+            return kRGBA_8888_GrPixelConfig;
+        case dawn::TextureFormat::B8G8R8A8Unorm:
+            return kBGRA_8888_GrPixelConfig;
+        case dawn::TextureFormat::R8Unorm:
+            return kAlpha_8_GrPixelConfig;
+        case dawn::TextureFormat::D32FloatS8Uint:
+        default:
+            SkASSERT(false);
+            return kRGBA_8888_GrPixelConfig;
+    }
+}
+
+bool GrPixelConfigToDawnFormat(GrPixelConfig config, dawn::TextureFormat* format) {
+    switch (config) {
+        case kRGBA_8888_GrPixelConfig:
+        case kRGBA_4444_GrPixelConfig:
+        case kRGB_565_GrPixelConfig:
+        case kGray_8_GrPixelConfig:
+            *format = dawn::TextureFormat::R8G8B8A8Unorm;
+            return true;
+        case kBGRA_8888_GrPixelConfig:
+            *format = dawn::TextureFormat::B8G8R8A8Unorm;
+            return true;
+        case kAlpha_8_GrPixelConfig:
+            *format = dawn::TextureFormat::R8Unorm;
+            return true;
+        default:
+            return false;
+    }
+}
diff --git a/src/gpu/dawn/GrDawnUtil.h b/src/gpu/dawn/GrDawnUtil.h
new file mode 100644
index 0000000..6cf973d
--- /dev/null
+++ b/src/gpu/dawn/GrDawnUtil.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnUtil_DEFINED
+#define GrDawnUtil_DEFINED
+
+#include "include/private/GrTypesPriv.h"
+#include "dawn/dawncpp.h"
+
+GrPixelConfig GrDawnFormatToPixelConfig(dawn::TextureFormat format);
+bool GrPixelConfigToDawnFormat(GrPixelConfig config, dawn::TextureFormat* format);
+
+#endif // GrDawnUtil_DEFINED