diff --git a/BUILD.gn b/BUILD.gn
index 75db39a..3d52019 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1794,9 +1794,8 @@
   if (!is_win && skia_enable_gpu) {
     test_lib("skqp_lib") {
       public_include_dirs = [ "tools/skqp" ]
-      defines = [
-        "SK_SKQP_GLOBAL_ERROR_TOLERANCE=$skia_skqp_global_error_tolerance"
-      ]
+      defines =
+          [ "SK_SKQP_GLOBAL_ERROR_TOLERANCE=$skia_skqp_global_error_tolerance" ]
       if (skia_skqp_enable_driver_correctness_workarounds) {
         defines += [ "SK_SKQP_ENABLE_DRIVER_CORRECTNESS_WORKAROUNDS" ]
       }
diff --git a/gn/tests.gni b/gn/tests.gni
index b218c5c..66b6637 100644
--- a/gn/tests.gni
+++ b/gn/tests.gni
@@ -274,6 +274,7 @@
   "$_tests/UtilsTest.cpp",
   "$_tests/VerticesTest.cpp",
   "$_tests/VkClearTests.cpp",
+  "$_tests/VkHardwareBufferTest.cpp",
   "$_tests/VkHeapTests.cpp",
   "$_tests/VkMakeCopyPipelineTest.cpp",
   "$_tests/VkUploadPixelsTests.cpp",
diff --git a/include/gpu/vk/GrVkTypes.h b/include/gpu/vk/GrVkTypes.h
index 5e93733..e0370cd 100644
--- a/include/gpu/vk/GrVkTypes.h
+++ b/include/gpu/vk/GrVkTypes.h
@@ -31,19 +31,32 @@
  * Vulkan textures are really const GrVkImageInfo*
  */
 struct GrVkAlloc {
-    VkDeviceMemory fMemory = VK_NULL_HANDLE;  // can be VK_NULL_HANDLE iff is an RT and is borrowed
-    VkDeviceSize   fOffset = 0;
-    VkDeviceSize   fSize = 0;    // this can be indeterminate iff Tex uses borrow semantics
-    uint32_t       fFlags= 0;
+    GrVkAlloc()
+            : fMemory(VK_NULL_HANDLE)
+            , fOffset(0)
+            , fSize(0)
+            , fFlags(0)
+            , fUsesSystemHeap(false) {}
+
+    GrVkAlloc(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, uint32_t flags)
+            : fMemory(memory)
+            , fOffset(offset)
+            , fSize(size)
+            , fFlags(flags)
+            , fUsesSystemHeap(false) {}
+
+    VkDeviceMemory fMemory;  // can be VK_NULL_HANDLE iff is an RT and is borrowed
+    VkDeviceSize   fOffset;
+    VkDeviceSize   fSize;    // this can be indeterminate iff Tex uses borrow semantics
+    uint32_t       fFlags;
 
     enum Flag {
         kNoncoherent_Flag = 0x1,   // memory must be flushed to device after mapping
     };
 private:
     friend class GrVkHeap; // For access to usesSystemHeap
-    bool fUsesSystemHeap = false;
+    bool fUsesSystemHeap;
 };
-
 struct GrVkImageInfo {
     /**
      * If the image's format is sRGB (GrVkFormatIsSRGB returns true), then the image must have
@@ -55,6 +68,8 @@
     VkImageLayout  fImageLayout;
     VkFormat       fFormat;
     uint32_t       fLevelCount;
+    uint32_t       fInitialQueueFamily = VK_QUEUE_FAMILY_IGNORED;
+    uint32_t       fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
 
     // This gives a way for a client to update the layout of the Image if they change the layout
     // while we're still holding onto the wrapped texture. They will first need to get a handle
diff --git a/platform_tools/android/apps/skqp/src/main/assets/skqp/KnownGpuUnitTests.txt b/platform_tools/android/apps/skqp/src/main/assets/skqp/KnownGpuUnitTests.txt
index 064fdc0..c48f6cc 100644
--- a/platform_tools/android/apps/skqp/src/main/assets/skqp/KnownGpuUnitTests.txt
+++ b/platform_tools/android/apps/skqp/src/main/assets/skqp/KnownGpuUnitTests.txt
@@ -137,6 +137,12 @@
 VkMakeCopyPipelineTest
 VkUploadPixelsTests
 VkWrapTests
+VulkanHardwareBuffer_CPU_Vulkan
+VulkanHardwareBuffer_EGL_Vulkan
+VulkanHardwareBuffer_Vulkan_Vulkan
+VulkanHardwareBuffer_CPU_EGL
+VulkanHardwareBuffer_EGL_EGL
+VulkanHardwareBuffer_Vulkan_EGL
 WrappedProxyConversionTest
 WrappedProxyTest
 WritePixelsNonTexture_Gpu
diff --git a/src/gpu/GrAHardwareBufferImageGenerator.cpp b/src/gpu/GrAHardwareBufferImageGenerator.cpp
index 085d27a..b95e394 100644
--- a/src/gpu/GrAHardwareBufferImageGenerator.cpp
+++ b/src/gpu/GrAHardwareBufferImageGenerator.cpp
@@ -162,7 +162,7 @@
 
     while (GL_NO_ERROR != glGetError()) {} //clear GL errors
 
-    EGLClientBuffer  clientBuffer = eglGetNativeClientBufferANDROID(fGraphicBuffer);
+    EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(fGraphicBuffer);
     EGLint attribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
                          EGL_NONE };
     EGLDisplay display = eglGetCurrentDisplay();
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 30e565f..f0c8c18 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -470,6 +470,12 @@
     virtual void deleteTestingOnlyBackendTexture(GrBackendTexture*,
                                                  bool abandonTexture = false) = 0;
 
+    /**
+     * Flushes all work to the gpu and forces the GPU to wait until all the gpu work has completed.
+     * This is for testing purposes only.
+     */
+    virtual void testingOnly_flushGpuAndSync() = 0;
+
     // width and height may be larger than rt (if underlying API allows it).
     // Returns nullptr if compatible sb could not be created, otherwise the caller owns the ref on
     // the GrStencilAttachment.
diff --git a/src/gpu/ddl/GrDDLGpu.h b/src/gpu/ddl/GrDDLGpu.h
index 0508a2e..25f647d 100644
--- a/src/gpu/ddl/GrDDLGpu.h
+++ b/src/gpu/ddl/GrDDLGpu.h
@@ -170,6 +170,8 @@
     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override;
     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandon = false) override;
 
+    void testingOnly_flushGpuAndSync() override {}
+
     typedef GrGpu INHERITED;
 };
 
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index fb0622b..933251e 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -4498,6 +4498,10 @@
     fProgramCache->abandon();
 }
 
+void GrGLGpu::testingOnly_flushGpuAndSync() {
+    GL_CALL(Finish());
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLAttribArrayState* GrGLGpu::HWVertexArrayState::bindInternalVertexArray(GrGLGpu* gpu,
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 0d55e50..285b9d3 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -168,6 +168,8 @@
 
     void resetShaderCacheForTesting() const override;
 
+    void testingOnly_flushGpuAndSync() override;
+
     GrFence SK_WARN_UNUSED_RESULT insertFence() override;
     bool waitFence(GrFence, uint64_t timeout) override;
     void deleteFence(GrFence) const override;
diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h
index b99857f..ff41c27 100644
--- a/src/gpu/mock/GrMockGpu.h
+++ b/src/gpu/mock/GrMockGpu.h
@@ -137,6 +137,8 @@
     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override;
     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandonTexture = false) override;
 
+    void testingOnly_flushGpuAndSync() override {}
+
     static int NextInternalTextureID();
     static int NextExternalTextureID();
 
diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h
index 9199f03..8ae71b9 100644
--- a/src/gpu/mtl/GrMtlGpu.h
+++ b/src/gpu/mtl/GrMtlGpu.h
@@ -151,6 +151,8 @@
     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override { return false; }
     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandon = false) override {}
 
+    void testingOnly_flushGpuAndSync() override {}
+
     sk_sp<GrMtlCaps> fMtlCaps;
 
     id<MTLDevice> fDevice;
diff --git a/src/gpu/vk/GrVkExtensions.cpp b/src/gpu/vk/GrVkExtensions.cpp
index 17737f1..31cc986 100644
--- a/src/gpu/vk/GrVkExtensions.cpp
+++ b/src/gpu/vk/GrVkExtensions.cpp
@@ -89,9 +89,7 @@
         return false;
     }
     for (uint32_t i = 0; i < extensionCount; ++i) {
-        if (nonPatchVersion >= remove_patch_version(extensions[i].specVersion)) {
-            fInstanceExtensionStrings->push_back() = extensions[i].extensionName;
-        }
+        fInstanceExtensionStrings->push_back() = extensions[i].extensionName;
     }
     delete [] extensions;
     // sort so we can search
@@ -183,9 +181,7 @@
         return false;
     }
     for (uint32_t i = 0; i < extensionCount; ++i) {
-        if (nonPatchVersion >= remove_patch_version(extensions[i].specVersion)) {
-            fDeviceExtensionStrings->push_back() = extensions[i].extensionName;
-        }
+        fDeviceExtensionStrings->push_back() = extensions[i].extensionName;
     }
     delete[] extensions;
     if (!fDeviceExtensionStrings->empty()) {
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 1269eaa..2433039 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -1575,6 +1575,10 @@
     }
 }
 
+void GrVkGpu::testingOnly_flushGpuAndSync() {
+    this->submitCommandBuffer(kForce_SyncQueue);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkGpu::addMemoryBarrier(VkPipelineStageFlags srcStageMask,
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 85fb213..53701bf 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -50,6 +50,7 @@
 
     VkDevice device() const { return fDevice; }
     VkQueue  queue() const { return fQueue; }
+    uint32_t  queueIndex() const { return fBackendContext->fGraphicsQueueIndex; }
     VkCommandPool cmdPool() const { return fCmdPool; }
     VkPhysicalDeviceProperties physicalDeviceProperties() const {
         return fPhysDevProps;
@@ -89,6 +90,8 @@
     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override;
     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandonTexture = false) override;
 
+    void testingOnly_flushGpuAndSync() override;
+
     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
                                                                 int width,
                                                                 int height) override;
diff --git a/src/gpu/vk/GrVkImage.cpp b/src/gpu/vk/GrVkImage.cpp
index 5e0ffe2..71e3682 100644
--- a/src/gpu/vk/GrVkImage.cpp
+++ b/src/gpu/vk/GrVkImage.cpp
@@ -28,14 +28,21 @@
 void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout,
                                VkAccessFlags dstAccessMask,
                                VkPipelineStageFlags dstStageMask,
-                               bool byRegion) {
+                               bool byRegion,
+                               bool releaseFamilyQueue) {
     SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
              VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
     VkImageLayout currentLayout = this->currentLayout();
 
+    if (releaseFamilyQueue && fInfo.fCurrentQueueFamily == fInfo.fInitialQueueFamily) {
+        // We never transfered the image to this queue and we are releasing it so don't do anything.
+        return;
+    }
+
     // If the old and new layout are the same and the layout is a read only layout, there is no need
     // to put in a barrier.
     if (newLayout == currentLayout &&
+        !releaseFamilyQueue &&
         (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == currentLayout ||
          VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == currentLayout ||
          VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == currentLayout)) {
@@ -46,6 +53,19 @@
     VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(currentLayout);
 
     VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fInfo.fFormat);
+
+    uint32_t srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    uint32_t dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    if (VK_QUEUE_FAMILY_IGNORED != fInfo.fCurrentQueueFamily) {
+        srcQueueFamilyIndex = fInfo.fInitialQueueFamily;
+        dstQueueFamilyIndex = gpu->queueIndex();
+        fInfo.fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
+    } else if (releaseFamilyQueue) {
+        srcQueueFamilyIndex = gpu->queueIndex();
+        dstQueueFamilyIndex = fInfo.fInitialQueueFamily;
+        fInfo.fCurrentQueueFamily = fInfo.fInitialQueueFamily;
+    }
+
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
         nullptr,                                         // pNext
@@ -53,8 +73,8 @@
         dstAccessMask,                                   // inputMask
         currentLayout,                                   // oldLayout
         newLayout,                                       // newLayout
-        VK_QUEUE_FAMILY_IGNORED,                         // srcQueueFamilyIndex
-        VK_QUEUE_FAMILY_IGNORED,                         // dstQueueFamilyIndex
+        srcQueueFamilyIndex,                             // srcQueueFamilyIndex
+        dstQueueFamilyIndex,                             // dstQueueFamilyIndex
         fInfo.fImage,                                    // image
         { aspectFlags, 0, fInfo.fLevelCount, 0, 1 }      // subresourceRange
     };
@@ -139,6 +159,9 @@
 }
 
 void GrVkImage::releaseImage(const GrVkGpu* gpu) {
+    if (VK_QUEUE_FAMILY_IGNORED != fInfo.fInitialQueueFamily) {
+        this->setImageLayout(gpu, fInfo.fImageLayout, 0, 0, false, true);
+    }
     if (fResource) {
         fResource->unref(gpu);
         fResource = nullptr;
diff --git a/src/gpu/vk/GrVkImage.h b/src/gpu/vk/GrVkImage.h
index 587c3a8..9adbc2b 100644
--- a/src/gpu/vk/GrVkImage.h
+++ b/src/gpu/vk/GrVkImage.h
@@ -50,7 +50,8 @@
                         VkImageLayout newLayout,
                         VkAccessFlags dstAccessMask,
                         VkPipelineStageFlags dstStageMask,
-                        bool byRegion);
+                        bool byRegion,
+                        bool releaseFamilyQueue = false);
 
     struct ImageDesc {
         VkImageType         fImageType;
diff --git a/src/sksl/SkSLParser.cpp b/src/sksl/SkSLParser.cpp
index 1b6690d..986d8c0 100644
--- a/src/sksl/SkSLParser.cpp
+++ b/src/sksl/SkSLParser.cpp
@@ -1449,6 +1449,7 @@
                 result = std::unique_ptr<ASTExpression>(new ASTBinaryExpression(std::move(result),
                                                                                 std::move(t),
                                                                                 std::move(right)));
+                return result;
             }
             default:
                 return result;
diff --git a/tests/GrMipMappedTest.cpp b/tests/GrMipMappedTest.cpp
index 0436bd4..d02095b 100644
--- a/tests/GrMipMappedTest.cpp
+++ b/tests/GrMipMappedTest.cpp
@@ -201,14 +201,9 @@
             }
 
             // Must make sure the uses of the backend texture have finished (we possibly have a
-            // queued up copy) before we delete the backend texture. Thus we use readPixels here
-            // just to force the synchronization.
-            sk_sp<GrSurfaceContext> surfContext =
-                    context->contextPriv().makeWrappedSurfaceContext(genProxy);
-
-            SkBitmap bitmap;
-            bitmap.allocPixels(imageInfo);
-            surfContext->readPixels(imageInfo, bitmap.getPixels(), 0, 0, 0, 0);
+            // queued up copy) before we delete the backend texture.
+            context->flush();
+            gpu->testingOnly_flushGpuAndSync();
 
             gpu->deleteTestingOnlyBackendTexture(&backendTex);
         }
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index a1472d4..689fc38 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -859,13 +859,9 @@
             otherTestContext->makeCurrent();
             canvas->flush();
 
-            // This readPixels call is needed for Vulkan to make sure the ReleaseProc is called.
-            // Even though we flushed above, this does not guarantee the command buffer will finish
-            // which is when we call the ReleaseProc. The readPixels forces a CPU sync so we know
-            // that the command buffer has finished and we've called the ReleaseProc.
-            SkBitmap bitmap;
-            bitmap.allocPixels(info);
-            canvas->readPixels(bitmap, 0, 0);
+            // This is specifically here for vulkan to guarantee the command buffer will finish
+            // which is when we call the ReleaseProc.
+            otherCtx->contextPriv().getGpu()->testingOnly_flushGpuAndSync();
         }
 
         // Case #6: Verify that only one context can be using the image at a time
diff --git a/tests/VkHardwareBufferTest.cpp b/tests/VkHardwareBufferTest.cpp
new file mode 100644
index 0000000..86f673e
--- /dev/null
+++ b/tests/VkHardwareBufferTest.cpp
@@ -0,0 +1,1245 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This is a GPU-backend specific test. It relies on static intializers to work
+
+#include "SkTypes.h"
+
+#ifdef SKQP_BUILD_HARDWAREBUFFER_TEST
+#if SK_SUPPORT_GPU && defined(SK_VULKAN)
+
+#include "GrContext.h"
+#include "GrContextFactory.h"
+#include "GrContextPriv.h"
+#include "GrGpu.h"
+#include "GrProxyProvider.h"
+#include "GrTest.h"
+#include "SkAutoMalloc.h"
+#include "SkCanvas.h"
+#include "SkGr.h"
+#include "SkImage.h"
+#include "SkSurface.h"
+#include "Test.h"
+#include "../tools/gpu/vk/VkTestUtils.h"
+#include "gl/GrGLDefines.h"
+#include "gl/GrGLUtil.h"
+#include "vk/GrVkBackendContext.h"
+#include "vk/GrVkExtensions.h"
+
+#include <android/hardware_buffer.h>
+#include <cinttypes>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+static const int DEV_W = 16, DEV_H = 16;
+
+class BaseTestHelper {
+public:
+    virtual ~BaseTestHelper() {}
+
+    virtual void cleanup() = 0;
+    virtual void releaseImage() = 0;
+
+    virtual sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
+                                                       AHardwareBuffer* buffer) = 0;
+    virtual sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
+                                                          AHardwareBuffer* buffer) = 0;
+
+    virtual void doClientSync() = 0;
+
+    virtual GrContext* grContext() = 0;
+
+protected:
+    BaseTestHelper() {}
+};
+
+class EGLTestHelper : public BaseTestHelper {
+public:
+    EGLTestHelper(const GrContextOptions& options) : fFactory(options) {}
+
+    ~EGLTestHelper() override {}
+
+    void releaseImage() override {
+        if (!fGLCtx) {
+            return;
+        }
+        if (EGL_NO_IMAGE_KHR != fImage) {
+            fGLCtx->destroyEGLImage(fImage);
+            fImage = EGL_NO_IMAGE_KHR;
+        }
+        if (fTexID) {
+            GR_GL_CALL(fGLCtx->gl(), DeleteTextures(1, &fTexID));
+            fTexID = 0;
+        }
+    }
+
+    void cleanup() override {
+        this->releaseImage();
+    }
+
+    bool init(skiatest::Reporter* reporter);
+
+    sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
+                                               AHardwareBuffer* buffer) override;
+    sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
+                                                  AHardwareBuffer* buffer) override;
+
+    void doClientSync() override;
+
+    GrContext* grContext() override { return fGrContext; }
+
+private:
+    bool importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer);
+
+    typedef EGLClientBuffer (*EGLGetNativeClientBufferANDROIDProc)(const struct AHardwareBuffer*);
+    typedef EGLImageKHR (*EGLCreateImageKHRProc)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer,
+                                                 const EGLint*);
+    typedef void (*EGLImageTargetTexture2DOESProc)(EGLenum, void*);
+    EGLGetNativeClientBufferANDROIDProc fEGLGetNativeClientBufferANDROID;
+    EGLCreateImageKHRProc fEGLCreateImageKHR;
+    EGLImageTargetTexture2DOESProc fEGLImageTargetTexture2DOES;
+
+    EGLImageKHR fImage = EGL_NO_IMAGE_KHR;
+    GrGLuint fTexID = 0;
+
+    sk_gpu_test::GrContextFactory fFactory;
+    sk_gpu_test::ContextInfo fGLESContextInfo;
+
+    sk_gpu_test::GLTestContext* fGLCtx = nullptr;
+    GrContext* fGrContext = nullptr;
+};
+
+bool EGLTestHelper::init(skiatest::Reporter* reporter) {
+    fGLESContextInfo = fFactory.getContextInfo(sk_gpu_test::GrContextFactory::kGLES_ContextType);
+    fGrContext = fGLESContextInfo.grContext();
+    fGLCtx = fGLESContextInfo.glContext();
+    if (!fGrContext || !fGLCtx) {
+        return false;
+    }
+
+    if (kGLES_GrGLStandard != fGLCtx->gl()->fStandard) {
+        return false;
+    }
+
+    // Confirm we have egl and the needed extensions
+    if (!fGLCtx->gl()->hasExtension("EGL_KHR_image") ||
+        !fGLCtx->gl()->hasExtension("EGL_ANDROID_get_native_client_buffer") ||
+        !fGLCtx->gl()->hasExtension("GL_OES_EGL_image_external") ||
+        !fGLCtx->gl()->hasExtension("GL_OES_EGL_image") ||
+        !fGLCtx->gl()->hasExtension("EGL_KHR_fence_sync")) {
+        return false;
+    }
+
+    fEGLGetNativeClientBufferANDROID =
+        (EGLGetNativeClientBufferANDROIDProc) eglGetProcAddress("eglGetNativeClientBufferANDROID");
+    if (!fEGLGetNativeClientBufferANDROID) {
+        ERRORF(reporter, "Failed to get the eglGetNativeClientBufferAndroid proc");
+        return false;
+    }
+
+    fEGLCreateImageKHR = (EGLCreateImageKHRProc) eglGetProcAddress("eglCreateImageKHR");
+    if (!fEGLCreateImageKHR) {
+        ERRORF(reporter, "Failed to get the proc eglCreateImageKHR");
+        return false;
+    }
+
+    fEGLImageTargetTexture2DOES =
+            (EGLImageTargetTexture2DOESProc) eglGetProcAddress("glEGLImageTargetTexture2DOES");
+    if (!fEGLImageTargetTexture2DOES) {
+        ERRORF(reporter, "Failed to get the proc EGLImageTargetTexture2DOES");
+        return false;
+    }
+    return true;
+}
+
+bool EGLTestHelper::importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer) {
+    GrGLClearErr(fGLCtx->gl());
+
+    EGLClientBuffer eglClientBuffer = fEGLGetNativeClientBufferANDROID(buffer);
+    EGLint eglAttribs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
+                            EGL_NONE };
+    EGLDisplay eglDisplay = eglGetCurrentDisplay();
+    fImage = fEGLCreateImageKHR(eglDisplay, EGL_NO_CONTEXT,
+                                EGL_NATIVE_BUFFER_ANDROID,
+                                eglClientBuffer, eglAttribs);
+    if (EGL_NO_IMAGE_KHR == fImage) {
+        SkDebugf("Could not create EGL image, err = (%#x)\n", (int) eglGetError() );
+        return false;
+    }
+
+    GR_GL_CALL(fGLCtx->gl(), GenTextures(1, &fTexID));
+    if (!fTexID) {
+        ERRORF(reporter, "Failed to create GL Texture");
+        return false;
+    }
+    GR_GL_CALL_NOERRCHECK(fGLCtx->gl(), BindTexture(GR_GL_TEXTURE_2D, fTexID));
+    if (GR_GL_GET_ERROR(fGLCtx->gl()) != GR_GL_NO_ERROR) {
+        ERRORF(reporter, "Failed to bind GL Texture");
+        return false;
+    }
+
+    fEGLImageTargetTexture2DOES(GL_TEXTURE_2D, fImage);
+    GLenum status = GL_NO_ERROR;
+    if ((status = glGetError()) != GL_NO_ERROR) {
+        ERRORF(reporter, "EGLImageTargetTexture2DOES failed (%#x)", (int) status);
+        return false;
+    }
+
+    fGrContext->resetContext(kTextureBinding_GrGLBackendState);
+    return true;
+}
+
+sk_sp<SkImage> EGLTestHelper::importHardwareBufferForRead(skiatest::Reporter* reporter,
+                                                          AHardwareBuffer* buffer) {
+    if (!this->importHardwareBuffer(reporter, buffer)) {
+        return nullptr;
+    }
+    GrGLTextureInfo textureInfo;
+    textureInfo.fTarget = GR_GL_TEXTURE_2D;
+    textureInfo.fID = fTexID;
+    textureInfo.fFormat = GR_GL_RGBA8;
+
+    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
+    REPORTER_ASSERT(reporter, backendTex.isValid());
+
+    sk_sp<SkImage> image = SkImage::MakeFromTexture(fGrContext,
+                                                               backendTex,
+                                                               kTopLeft_GrSurfaceOrigin,
+                                                               kRGBA_8888_SkColorType,
+                                                               kPremul_SkAlphaType,
+                                                               nullptr);
+
+    if (!image) {
+        ERRORF(reporter, "Failed to make wrapped GL SkImage");
+        return nullptr;
+    }
+
+    return image;
+}
+
+sk_sp<SkSurface> EGLTestHelper::importHardwareBufferForWrite(skiatest::Reporter* reporter,
+                                                             AHardwareBuffer* buffer) {
+    if (!this->importHardwareBuffer(reporter, buffer)) {
+        return nullptr;
+    }
+    GrGLTextureInfo textureInfo;
+    textureInfo.fTarget = GR_GL_TEXTURE_2D;
+    textureInfo.fID = fTexID;
+    textureInfo.fFormat = GR_GL_RGBA8;
+
+    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
+    REPORTER_ASSERT(reporter, backendTex.isValid());
+
+    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(fGrContext,
+                                                                 backendTex,
+                                                                 kTopLeft_GrSurfaceOrigin,
+                                                                 1,
+                                                                 kRGBA_8888_SkColorType,
+                                                                 nullptr, nullptr);
+
+    if (!surface) {
+        ERRORF(reporter, "Failed to make wrapped GL SkSurface");
+        return nullptr;
+    }
+
+    return surface;
+}
+
+void EGLTestHelper::doClientSync() {
+    sk_gpu_test::FenceSync* fenceSync = fGLCtx->fenceSync();
+    sk_gpu_test::PlatformFence fence = fenceSync->insertFence();
+    fenceSync->waitFence(fence);
+    fenceSync->deleteFence(fence);
+}
+
+#define DECLARE_VK_PROC(name) PFN_vk##name fVk##name
+
+#define ACQUIRE_VK_PROC(name, instance, device)                                        \
+    fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, instance, device)); \
+    if (fVk##name == nullptr) {                                                        \
+        ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);      \
+        return false;                                                                  \
+    }
+
+#define ACQUIRE_INST_VK_PROC(name)                                                          \
+    fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, fInst, VK_NULL_HANDLE)); \
+    if (fVk##name == nullptr) {                                                             \
+        ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);           \
+        fVkDestroyInstance(fInst, nullptr);                                                 \
+        return false;                                                                       \
+    }
+
+#define ACQUIRE_DEVICE_VK_PROC(name)                                                          \
+    fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, VK_NULL_HANDLE, fDevice)); \
+    if (fVk##name == nullptr) {                                                               \
+        ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);             \
+        fVkDestroyDevice(fDevice, nullptr);                                                   \
+        fVkDestroyInstance(fInst, nullptr);                                                   \
+        return false;                                                                         \
+    }
+
+#ifdef SK_ENABLE_VK_LAYERS
+const char* kMyDebugLayerNames[] = {
+    // elements of VK_LAYER_LUNARG_standard_validation
+    "VK_LAYER_GOOGLE_threading",
+    "VK_LAYER_LUNARG_parameter_validation",
+    "VK_LAYER_LUNARG_object_tracker",
+    "VK_LAYER_LUNARG_image",
+    "VK_LAYER_LUNARG_core_validation",
+    "VK_LAYER_LUNARG_swapchain",
+    "VK_LAYER_GOOGLE_unique_objects",
+    // not included in standard_validation
+    //"VK_LAYER_LUNARG_api_dump",
+    //"VK_LAYER_LUNARG_vktrace",
+    //"VK_LAYER_LUNARG_screenshot",
+};
+#endif
+
+class VulkanTestHelper : public BaseTestHelper {
+public:
+    VulkanTestHelper() {}
+
+    ~VulkanTestHelper() override {}
+
+    void releaseImage() override {
+        if (VK_NULL_HANDLE == fDevice) {
+            return;
+        }
+        if (fImage != VK_NULL_HANDLE) {
+            SkASSERT(fVkDestroyImage);
+            fVkDestroyImage(fDevice, fImage, nullptr);
+            fImage = VK_NULL_HANDLE;
+        }
+
+        if (fMemory != VK_NULL_HANDLE) {
+            SkASSERT(fVkFreeMemory);
+            fVkFreeMemory(fDevice, fMemory, nullptr);
+            fMemory = VK_NULL_HANDLE;
+        }
+    }
+    void cleanup() override {
+        this->releaseImage();
+
+        fGrContext.reset();
+        fBackendContext.reset();
+
+        fInst = VK_NULL_HANDLE;
+        fPhysDev = VK_NULL_HANDLE;
+        fDevice = VK_NULL_HANDLE;
+    }
+
+    bool init(skiatest::Reporter* reporter);
+
+    void doClientSync() override {
+        if (!fGrContext) {
+            return;
+        }
+
+        fGrContext->contextPriv().getGpu()->testingOnly_flushGpuAndSync();
+    }
+
+    bool checkOptimalHardwareBuffer(skiatest::Reporter* reporter);
+
+    sk_sp<SkImage> importHardwareBufferForRead(skiatest::Reporter* reporter,
+                                               AHardwareBuffer* buffer) override;
+
+    sk_sp<SkSurface> importHardwareBufferForWrite(skiatest::Reporter* reporter,
+                                                  AHardwareBuffer* buffer) override;
+
+    GrContext* grContext() override { return fGrContext.get(); }
+
+private:
+    bool importHardwareBuffer(skiatest::Reporter* reporter, AHardwareBuffer* buffer, bool forWrite,
+                              GrVkImageInfo* outImageInfo);
+
+    DECLARE_VK_PROC(EnumerateInstanceVersion);
+    DECLARE_VK_PROC(CreateInstance);
+    DECLARE_VK_PROC(DestroyInstance);
+    DECLARE_VK_PROC(EnumeratePhysicalDevices);
+    DECLARE_VK_PROC(GetPhysicalDeviceProperties);
+    DECLARE_VK_PROC(GetPhysicalDeviceMemoryProperties2);
+    DECLARE_VK_PROC(GetPhysicalDeviceQueueFamilyProperties);
+    DECLARE_VK_PROC(GetPhysicalDeviceFeatures);
+    DECLARE_VK_PROC(CreateDevice);
+    DECLARE_VK_PROC(GetDeviceQueue);
+    DECLARE_VK_PROC(DeviceWaitIdle);
+    DECLARE_VK_PROC(DestroyDevice);
+    DECLARE_VK_PROC(GetPhysicalDeviceImageFormatProperties2);
+    DECLARE_VK_PROC(CreateImage);
+    DECLARE_VK_PROC(GetImageMemoryRequirements2);
+    DECLARE_VK_PROC(GetAndroidHardwareBufferPropertiesANDROID);
+    DECLARE_VK_PROC(AllocateMemory);
+    DECLARE_VK_PROC(BindImageMemory2);
+    DECLARE_VK_PROC(DestroyImage);
+    DECLARE_VK_PROC(FreeMemory);
+
+    VkInstance fInst = VK_NULL_HANDLE;
+    VkPhysicalDevice fPhysDev = VK_NULL_HANDLE;
+    VkDevice fDevice = VK_NULL_HANDLE;
+
+    VkImage fImage = VK_NULL_HANDLE;
+    VkDeviceMemory fMemory = VK_NULL_HANDLE;
+
+    sk_sp<GrVkBackendContext> fBackendContext;
+    sk_sp<GrContext> fGrContext;
+};
+
+bool VulkanTestHelper::init(skiatest::Reporter* reporter) {
+    PFN_vkGetInstanceProcAddr instProc;
+    PFN_vkGetDeviceProcAddr devProc;
+    if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
+        return false;
+    }
+
+    auto getProc = [&instProc, &devProc](const char* proc_name,
+                                         VkInstance instance, VkDevice device) {
+        if (device != VK_NULL_HANDLE) {
+            return devProc(device, proc_name);
+        }
+        return instProc(instance, proc_name);
+    };
+
+    VkResult err;
+
+    ACQUIRE_VK_PROC(EnumerateInstanceVersion, VK_NULL_HANDLE, VK_NULL_HANDLE);
+    uint32_t instanceVersion = 0;
+    if (fVkEnumerateInstanceVersion) {
+        err = fVkEnumerateInstanceVersion(&instanceVersion);
+        if (err) {
+            ERRORF(reporter, "failed ot enumerate instance version. Err: %d\n", err);
+            return false;
+        }
+    }
+    if (instanceVersion < VK_MAKE_VERSION(1, 1, 0)) {
+        return false;
+    }
+
+    const VkApplicationInfo app_info = {
+        VK_STRUCTURE_TYPE_APPLICATION_INFO, // sType
+        nullptr,                            // pNext
+        "vkHWBTest",                        // pApplicationName
+        0,                                  // applicationVersion
+        "vkHWBTest",                        // pEngineName
+        0,                                  // engineVerison
+        instanceVersion,                    // apiVersion
+    };
+
+    GrVkExtensions extensions(getProc);
+    extensions.initInstance(instanceVersion);
+
+    SkTArray<const char*> instanceLayerNames;
+    SkTArray<const char*> instanceExtensionNames;
+    uint32_t extensionFlags = 0;
+#ifdef SK_ENABLE_VK_LAYERS
+    for (size_t i = 0; i < SK_ARRAY_COUNT(kMyDebugLayerNames); ++i) {
+        if (extensions.hasInstanceLayer(kMyDebugLayerNames[i])) {
+            instanceLayerNames.push_back(kMyDebugLayerNames[i]);
+        }
+    }
+    if (extensions.hasInstanceExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
+        instanceExtensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+        extensionFlags |= kEXT_debug_report_GrVkExtensionFlag;
+    }
+#endif
+
+    const VkInstanceCreateInfo instance_create = {
+        VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,    // sType
+        nullptr,                                   // pNext
+        0,                                         // flags
+        &app_info,                                 // pApplicationInfo
+        (uint32_t) instanceLayerNames.count(),     // enabledLayerNameCount
+        instanceLayerNames.begin(),                // ppEnabledLayerNames
+        (uint32_t) instanceExtensionNames.count(), // enabledExtensionNameCount
+        instanceExtensionNames.begin(),            // ppEnabledExtensionNames
+    };
+
+    ACQUIRE_VK_PROC(CreateInstance, VK_NULL_HANDLE, VK_NULL_HANDLE);
+    err = fVkCreateInstance(&instance_create, nullptr, &fInst);
+    if (err < 0) {
+        ERRORF(reporter, "vkCreateInstance failed: %d\n", err);
+        return false;
+    }
+
+    ACQUIRE_VK_PROC(DestroyInstance, fInst, VK_NULL_HANDLE);
+    ACQUIRE_INST_VK_PROC(EnumeratePhysicalDevices);
+    ACQUIRE_INST_VK_PROC(GetPhysicalDeviceProperties);
+    ACQUIRE_INST_VK_PROC(GetPhysicalDeviceMemoryProperties2);
+    ACQUIRE_INST_VK_PROC(GetPhysicalDeviceQueueFamilyProperties);
+    ACQUIRE_INST_VK_PROC(GetPhysicalDeviceFeatures);
+    ACQUIRE_INST_VK_PROC(CreateDevice);
+    ACQUIRE_INST_VK_PROC(GetDeviceQueue);
+    ACQUIRE_INST_VK_PROC(DeviceWaitIdle);
+    ACQUIRE_INST_VK_PROC(DestroyDevice);
+    ACQUIRE_INST_VK_PROC(GetPhysicalDeviceImageFormatProperties2);
+
+    uint32_t gpuCount;
+    err = fVkEnumeratePhysicalDevices(fInst, &gpuCount, nullptr);
+    if (err) {
+        ERRORF(reporter, "vkEnumeratePhysicalDevices failed: %d\n", err);
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+    if (!gpuCount) {
+        // We can no physical devices so this isn't an error and failure in the test.
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+    // Just returning the first physical device instead of getting the whole array.
+    // TODO: find best match for our needs
+    gpuCount = 1;
+    err = fVkEnumeratePhysicalDevices(fInst, &gpuCount, &fPhysDev);
+    if (err) {
+        ERRORF(reporter, "vkEnumeratePhysicalDevices failed: %d\n", err);
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    // query to get the initial queue props size
+    uint32_t queueCount;
+    fVkGetPhysicalDeviceQueueFamilyProperties(fPhysDev, &queueCount, nullptr);
+    if (!queueCount) {
+        ERRORF(reporter, "vkGetPhysicalDeviceQueueFamilyProperties returned no queues.\n");
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
+    // now get the actual queue props
+    VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
+
+    fVkGetPhysicalDeviceQueueFamilyProperties(fPhysDev, &queueCount, queueProps);
+
+    // iterate to find the graphics queue
+    uint32_t graphicsQueueIndex = queueCount;
+    for (uint32_t i = 0; i < queueCount; i++) {
+        if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+            graphicsQueueIndex = i;
+            break;
+        }
+    }
+    if (graphicsQueueIndex == queueCount) {
+        ERRORF(reporter, "Could not find any supported graphics queues.\n");
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    VkPhysicalDeviceProperties physDevProperties;
+    fVkGetPhysicalDeviceProperties(fPhysDev, &physDevProperties);
+    int physDevVersion = physDevProperties.apiVersion;
+
+    extensions.initDevice(physDevVersion, fInst, fPhysDev);
+
+    SkTArray<const char*> deviceLayerNames;
+    SkTArray<const char*> deviceExtensionNames;
+#ifdef SK_ENABLE_VK_LAYERS
+    for (size_t i = 0; i < SK_ARRAY_COUNT(kMyDebugLayerNames); ++i) {
+        if (extensions.hasDeviceLayer(kMyDebugLayerNames[i])) {
+            deviceLayerNames.push_back(kMyDebugLayerNames[i]);
+        }
+    }
+#endif
+
+    if (extensions.hasDeviceExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) {
+        deviceExtensionNames.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
+    } else {
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    if (extensions.hasDeviceExtension(
+            VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME)) {
+        deviceExtensionNames.push_back(
+                VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
+    } else {
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    if (extensions.hasDeviceExtension(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME)) {
+        deviceExtensionNames.push_back(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME);
+    } else {
+        SkDebugf("We don't have the extension for VK_EXT_QUEUE_FAMILY_FOREIGN\n");
+        //fVkDestroyInstance(fInst, nullptr);
+        //return false;
+    }
+
+    // query to get the physical device properties
+    VkPhysicalDeviceFeatures deviceFeatures;
+    fVkGetPhysicalDeviceFeatures(fPhysDev, &deviceFeatures);
+    // this looks like it would slow things down,
+    // and we can't depend on it on all platforms
+    deviceFeatures.robustBufferAccess = VK_FALSE;
+
+    uint32_t featureFlags = 0;
+    if (deviceFeatures.geometryShader) {
+        featureFlags |= kGeometryShader_GrVkFeatureFlag;
+    }
+    if (deviceFeatures.dualSrcBlend) {
+        featureFlags |= kDualSrcBlend_GrVkFeatureFlag;
+    }
+    if (deviceFeatures.sampleRateShading) {
+        featureFlags |= kSampleRateShading_GrVkFeatureFlag;
+    }
+
+    float queuePriorities[1] = { 0.0 };
+    // Here we assume no need for swapchain queue
+    // If one is needed, the client will need its own setup code
+    const VkDeviceQueueCreateInfo queueInfo[1] = {
+        {
+            VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+            nullptr,                                    // pNext
+            0,                                          // VkDeviceQueueCreateFlags
+            graphicsQueueIndex,                         // queueFamilyIndex
+            1,                                          // queueCount
+            queuePriorities,                            // pQueuePriorities
+        }
+    };
+    uint32_t queueInfoCount = 1;
+
+    const VkDeviceCreateInfo deviceInfo = {
+        VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,    // sType
+        nullptr,                                 // pNext
+        0,                                       // VkDeviceCreateFlags
+        queueInfoCount,                          // queueCreateInfoCount
+        queueInfo,                               // pQueueCreateInfos
+        (uint32_t) deviceLayerNames.count(),     // layerCount
+        deviceLayerNames.begin(),                // ppEnabledLayerNames
+        (uint32_t) deviceExtensionNames.count(), // extensionCount
+        deviceExtensionNames.begin(),            // ppEnabledExtensionNames
+        &deviceFeatures                          // ppEnabledFeatures
+    };
+
+    err = fVkCreateDevice(fPhysDev, &deviceInfo, nullptr, &fDevice);
+    if (err) {
+        ERRORF(reporter, "CreateDevice failed: %d\n", err);
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    ACQUIRE_DEVICE_VK_PROC(CreateImage);
+    ACQUIRE_DEVICE_VK_PROC(GetImageMemoryRequirements2);
+    ACQUIRE_DEVICE_VK_PROC(GetAndroidHardwareBufferPropertiesANDROID);
+    ACQUIRE_DEVICE_VK_PROC(AllocateMemory);
+    ACQUIRE_DEVICE_VK_PROC(BindImageMemory2);
+    ACQUIRE_DEVICE_VK_PROC(DestroyImage);
+    ACQUIRE_DEVICE_VK_PROC(FreeMemory);
+
+    VkQueue queue;
+    fVkGetDeviceQueue(fDevice, graphicsQueueIndex, 0, &queue);
+
+    // Setting up actual skia things now
+    auto interface =
+            sk_make_sp<GrVkInterface>(getProc, fInst, fDevice, extensionFlags);
+    if (!interface->validate(extensionFlags)) {
+        ERRORF(reporter, "Vulkan interface validation failed\n");
+        fVkDeviceWaitIdle(fDevice);
+        fVkDestroyDevice(fDevice, nullptr);
+        fVkDestroyInstance(fInst, nullptr);
+        return false;
+    }
+
+    fBackendContext.reset(new GrVkBackendContext());
+    fBackendContext->fInstance = fInst;
+    fBackendContext->fPhysicalDevice = fPhysDev;
+    fBackendContext->fDevice = fDevice;
+    fBackendContext->fQueue = queue;
+    fBackendContext->fGraphicsQueueIndex = graphicsQueueIndex;
+    fBackendContext->fMinAPIVersion = instanceVersion;
+    fBackendContext->fExtensions = extensionFlags;
+    fBackendContext->fFeatures = featureFlags;
+    fBackendContext->fInterface.reset(interface.release());
+    fBackendContext->fOwnsInstanceAndDevice = true;
+
+    fGrContext = GrContext::MakeVulkan(fBackendContext);
+    REPORTER_ASSERT(reporter, fGrContext.get());
+
+    return true;
+}
+
+bool VulkanTestHelper::checkOptimalHardwareBuffer(skiatest::Reporter* reporter) {
+    VkResult err;
+
+    VkPhysicalDeviceExternalImageFormatInfo externalImageFormatInfo;
+    externalImageFormatInfo.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
+    externalImageFormatInfo.pNext = nullptr;
+    externalImageFormatInfo.handleType =
+            VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
+    //externalImageFormatInfo.handType = 0x80;
+
+    // We will create the hardware buffer with gpu sampled so these usages should all be valid
+    VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT |
+                                   VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                   VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    VkPhysicalDeviceImageFormatInfo2 imageFormatInfo;
+    imageFormatInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
+    imageFormatInfo.pNext = &externalImageFormatInfo;
+    imageFormatInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+    imageFormatInfo.type = VK_IMAGE_TYPE_2D;
+    imageFormatInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+    imageFormatInfo.usage = usageFlags;
+    imageFormatInfo.flags = 0;
+
+    VkAndroidHardwareBufferUsageANDROID hwbUsage;
+    hwbUsage.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID;
+    hwbUsage.pNext = nullptr;
+
+    VkExternalImageFormatProperties externalImgFormatProps;
+    externalImgFormatProps.sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+    externalImgFormatProps.pNext = &hwbUsage;
+
+    VkImageFormatProperties2 imgFormProps;
+    imgFormProps.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+    imgFormProps.pNext = &externalImgFormatProps;
+
+    err = fVkGetPhysicalDeviceImageFormatProperties2(fPhysDev, &imageFormatInfo,
+                                                        &imgFormProps);
+    if (VK_SUCCESS != err) {
+        ERRORF(reporter, "vkGetPhysicalDeviceImageFormatProperites failed, err: %d", err);
+        return false;
+    }
+
+    const VkImageFormatProperties& imageFormatProperties = imgFormProps.imageFormatProperties;
+    REPORTER_ASSERT(reporter, DEV_W <= imageFormatProperties.maxExtent.width);
+    REPORTER_ASSERT(reporter, DEV_H <= imageFormatProperties.maxExtent.height);
+
+    const VkExternalMemoryProperties& externalImageFormatProps =
+            externalImgFormatProps.externalMemoryProperties;
+    REPORTER_ASSERT(reporter, SkToBool(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT &
+                                       externalImageFormatProps.externalMemoryFeatures));
+    REPORTER_ASSERT(reporter, SkToBool(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT &
+                                       externalImageFormatProps.externalMemoryFeatures));
+
+    REPORTER_ASSERT(reporter, SkToBool(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE &
+                                       hwbUsage.androidHardwareBufferUsage));
+
+    return true;
+}
+
+bool VulkanTestHelper::importHardwareBuffer(skiatest::Reporter* reporter,
+                                            AHardwareBuffer* buffer,
+                                            bool forWrite,
+                                            GrVkImageInfo* outImageInfo) {
+    VkResult err;
+
+    VkAndroidHardwareBufferFormatPropertiesANDROID hwbFormatProps;
+    hwbFormatProps.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
+    hwbFormatProps.pNext = nullptr;
+
+    VkAndroidHardwareBufferPropertiesANDROID hwbProps;
+    hwbProps.sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
+    hwbProps.pNext = &hwbFormatProps;
+
+    err = fVkGetAndroidHardwareBufferPropertiesANDROID(fDevice, buffer, &hwbProps);
+    if (VK_SUCCESS != err) {
+        ERRORF(reporter, "GetAndroidHardwareBufferPropertiesAndoird failed, err: %d", err);
+        return false;
+    }
+
+    REPORTER_ASSERT(reporter, VK_FORMAT_R8G8B8A8_UNORM == hwbFormatProps.format);
+    REPORTER_ASSERT(reporter,
+                    SkToBool(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & hwbFormatProps.formatFeatures) &&
+                    SkToBool(VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & hwbFormatProps.formatFeatures) &&
+                    SkToBool(VK_FORMAT_FEATURE_TRANSFER_DST_BIT & hwbFormatProps.formatFeatures));
+    if (forWrite) {
+        REPORTER_ASSERT(reporter,
+                SkToBool(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & hwbFormatProps.formatFeatures));
+
+    }
+
+    bool useExternalFormat = VK_FORMAT_UNDEFINED == hwbFormatProps.format;
+    const VkExternalFormatANDROID externalFormatInfo {
+        VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,             // sType
+        nullptr,                                               // pNext
+        useExternalFormat ? hwbFormatProps.externalFormat : 0, // externalFormat
+    };
+
+    const VkExternalMemoryImageCreateInfo externalMemoryImageInfo {
+        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, // sType
+        &externalFormatInfo, // pNext
+        //nullptr, // pNext
+        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, // handleTypes
+        //0x80, // handleTypes
+    };
+
+    VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT |
+                                   VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                   VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    if (forWrite) {
+        usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    }
+
+    const VkImageCreateInfo imageCreateInfo = {
+        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,         // sType
+        &externalMemoryImageInfo,                    // pNext
+        0,                                           // VkImageCreateFlags
+        VK_IMAGE_TYPE_2D,                            // VkImageType
+        hwbFormatProps.format,                       // VkFormat
+        { DEV_W, DEV_H, 1 },                         // VkExtent3D
+        1,                                           // mipLevels
+        1,                                           // arrayLayers
+        VK_SAMPLE_COUNT_1_BIT,                       // samples
+        VK_IMAGE_TILING_OPTIMAL,                     // VkImageTiling
+        usageFlags,                                  // VkImageUsageFlags
+        VK_SHARING_MODE_EXCLUSIVE,                   // VkSharingMode
+        0,                                           // queueFamilyCount
+        0,                                           // pQueueFamilyIndices
+        VK_IMAGE_LAYOUT_UNDEFINED,                   // initialLayout
+    };
+
+    err = fVkCreateImage(fDevice, &imageCreateInfo, nullptr, &fImage);
+    if (VK_SUCCESS != err) {
+        ERRORF(reporter, "Create Image failed, err: %d", err);
+        return false;
+    }
+
+    VkImageMemoryRequirementsInfo2 memReqsInfo;
+    memReqsInfo.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
+    memReqsInfo.pNext = nullptr;
+    memReqsInfo.image = fImage;
+
+    VkMemoryDedicatedRequirements dedicatedMemReqs;
+    dedicatedMemReqs.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
+    dedicatedMemReqs.pNext = nullptr;
+
+    VkMemoryRequirements2 memReqs;
+    memReqs.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
+    memReqs.pNext = &dedicatedMemReqs;
+
+    fVkGetImageMemoryRequirements2(fDevice, &memReqsInfo, &memReqs);
+    REPORTER_ASSERT(reporter, VK_TRUE == dedicatedMemReqs.requiresDedicatedAllocation);
+
+    VkPhysicalDeviceMemoryProperties2 phyDevMemProps;
+    phyDevMemProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+    phyDevMemProps.pNext = nullptr;
+
+    uint32_t typeIndex = 0;
+    uint32_t heapIndex = 0;
+    bool foundHeap = false;
+    fVkGetPhysicalDeviceMemoryProperties2(fPhysDev, &phyDevMemProps);
+    uint32_t memTypeCnt = phyDevMemProps.memoryProperties.memoryTypeCount;
+    for (uint32_t i = 0; i < memTypeCnt && !foundHeap; ++i) {
+        if (hwbProps.memoryTypeBits & (1 << i)) {
+            const VkPhysicalDeviceMemoryProperties& pdmp = phyDevMemProps.memoryProperties;
+            uint32_t supportedFlags = pdmp.memoryTypes[i].propertyFlags &
+                    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+            if (supportedFlags == VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
+                typeIndex = i;
+                heapIndex = pdmp.memoryTypes[i].heapIndex;
+                foundHeap = true;
+            }
+        }
+    }
+    if (!foundHeap) {
+        ERRORF(reporter, "Failed to find valid heap for imported memory");
+        return false;
+    }
+
+    VkImportAndroidHardwareBufferInfoANDROID hwbImportInfo;
+    hwbImportInfo.sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+    hwbImportInfo.pNext = nullptr;
+    hwbImportInfo.buffer = buffer;
+
+    VkMemoryDedicatedAllocateInfo dedicatedAllocInfo;
+    dedicatedAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
+    dedicatedAllocInfo.pNext = &hwbImportInfo;
+    dedicatedAllocInfo.image = fImage;
+    dedicatedAllocInfo.buffer = VK_NULL_HANDLE;
+
+    VkMemoryAllocateInfo allocInfo = {
+        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,      // sType
+        &dedicatedAllocInfo,                         // pNext
+        hwbProps.allocationSize,                     // allocationSize
+        typeIndex,                                   // memoryTypeIndex
+    };
+
+    err = fVkAllocateMemory(fDevice, &allocInfo, nullptr, &fMemory);
+    if (VK_SUCCESS != err) {
+        ERRORF(reporter, "AllocateMemory failed for imported buffer, err: %d", err);
+        return false;
+    }
+
+    VkBindImageMemoryInfo bindImageInfo;
+    bindImageInfo.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
+    bindImageInfo.pNext = nullptr;
+    bindImageInfo.image = fImage;
+    bindImageInfo.memory = fMemory;
+    bindImageInfo.memoryOffset = 0;
+
+    err = fVkBindImageMemory2(fDevice, 1, &bindImageInfo);
+    if (VK_SUCCESS != err) {
+        ERRORF(reporter, "BindImageMemory failed for imported buffer, err: %d", err);
+        return false;
+    }
+
+    outImageInfo->fImage = fImage;
+    outImageInfo->fAlloc = GrVkAlloc(fMemory, 0, hwbProps.allocationSize, 0);
+    outImageInfo->fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    outImageInfo->fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    outImageInfo->fFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    outImageInfo->fLevelCount = 1;
+    outImageInfo->fInitialQueueFamily = VK_QUEUE_FAMILY_EXTERNAL;
+    outImageInfo->fCurrentQueueFamily = VK_QUEUE_FAMILY_EXTERNAL;
+    return true;
+}
+
+sk_sp<SkImage> VulkanTestHelper::importHardwareBufferForRead(skiatest::Reporter* reporter,
+                                                             AHardwareBuffer* buffer) {
+    GrVkImageInfo imageInfo;
+    if (!this->importHardwareBuffer(reporter, buffer, false, &imageInfo)) {
+        return nullptr;
+    }
+
+    GrBackendTexture backendTex(DEV_W, DEV_H, imageInfo);
+
+    sk_sp<SkImage> wrappedImage = SkImage::MakeFromTexture(fGrContext.get(),
+                                                           backendTex,
+                                                           kTopLeft_GrSurfaceOrigin,
+                                                           kRGBA_8888_SkColorType,
+                                                           kPremul_SkAlphaType,
+                                                           nullptr);
+
+    if (!wrappedImage.get()) {
+        ERRORF(reporter, "Failed to create wrapped Vulkan SkImage");
+        return nullptr;
+    }
+
+    return wrappedImage;
+}
+
+sk_sp<SkSurface> VulkanTestHelper::importHardwareBufferForWrite(skiatest::Reporter* reporter,
+                                                                AHardwareBuffer* buffer) {
+    GrVkImageInfo imageInfo;
+    if (!this->importHardwareBuffer(reporter, buffer, false, &imageInfo)) {
+        return nullptr;
+    }
+
+    GrBackendTexture backendTex(DEV_W, DEV_H, imageInfo);
+
+    sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(fGrContext.get(),
+                                                                 backendTex,
+                                                                 kTopLeft_GrSurfaceOrigin,
+                                                                 1,
+                                                                 kRGBA_8888_SkColorType,
+                                                                 nullptr, nullptr);
+
+    if (!surface.get()) {
+        ERRORF(reporter, "Failed to create wrapped Vulkan SkSurface");
+        return nullptr;
+    }
+
+    return surface;
+}
+
+static SkPMColor get_src_color(int x, int y) {
+    SkASSERT(x >= 0 && x < DEV_W);
+    SkASSERT(y >= 0 && y < DEV_H);
+
+    U8CPU r = x;
+    U8CPU g = y;
+    U8CPU b = 0xc;
+
+    U8CPU a = 0xff;
+    switch ((x+y) % 5) {
+        case 0:
+            a = 0xff;
+            break;
+        case 1:
+            a = 0x80;
+            break;
+        case 2:
+            a = 0xCC;
+            break;
+        case 4:
+            a = 0x01;
+            break;
+        case 3:
+            a = 0x00;
+            break;
+    }
+    a = 0xff;
+    return SkPremultiplyARGBInline(a, r, g, b);
+}
+
+static SkBitmap make_src_bitmap() {
+    static SkBitmap bmp;
+    if (bmp.isNull()) {
+        bmp.allocN32Pixels(DEV_W, DEV_H);
+        intptr_t pixels = reinterpret_cast<intptr_t>(bmp.getPixels());
+        for (int y = 0; y < DEV_H; ++y) {
+            for (int x = 0; x < DEV_W; ++x) {
+                SkPMColor* pixel = reinterpret_cast<SkPMColor*>(
+                        pixels + y * bmp.rowBytes() + x * bmp.bytesPerPixel());
+                *pixel = get_src_color(x, y);
+            }
+        }
+    }
+    return bmp;
+}
+
+static bool check_read(skiatest::Reporter* reporter, const SkBitmap& srcBitmap,
+                       const SkBitmap& dstBitmap) {
+    bool result = true;
+    for (int y = 0; y < DEV_H; ++y) {
+        for (int x = 0; x < DEV_W; ++x) {
+            const uint32_t srcPixel = *srcBitmap.getAddr32(x, y);
+            const uint32_t dstPixel = *dstBitmap.getAddr32(x, y);
+            if (srcPixel != dstPixel) {
+                ERRORF(reporter, "Expected readback pixel (%d, %d) value 0x%08x, got 0x%08x.",
+                       x, y,  srcPixel, dstPixel);
+                result = false;
+            } /*else {
+                ERRORF(reporter, "Got good readback pixel (%d, %d) value 0x%08x, got 0x%08x.",
+                       x, y,  srcPixel, dstPixel);
+
+            }*/
+        }
+    }
+    return result;
+}
+
+static void cleanup_resources(BaseTestHelper* srcHelper, BaseTestHelper* dstHelper,
+                              AHardwareBuffer* buffer) {
+    if (srcHelper) {
+        srcHelper->cleanup();
+    }
+    if (dstHelper) {
+        dstHelper->cleanup();
+    }
+    if (buffer) {
+        AHardwareBuffer_release(buffer);
+    }
+}
+
+enum class SrcType {
+    kCPU,
+    kEGL,
+    kVulkan,
+};
+
+enum class DstType {
+    kEGL,
+    kVulkan,
+};
+
+void run_test(skiatest::Reporter* reporter, const GrContextOptions& options,
+              SrcType srcType, DstType dstType) {
+    VulkanTestHelper vulkanHelper;
+    EGLTestHelper eglHelper(options);
+    AHardwareBuffer* buffer = nullptr;
+    if (SrcType::kVulkan == srcType || DstType::kVulkan == dstType) {
+        if (!vulkanHelper.init(reporter)) {
+            cleanup_resources(&vulkanHelper, &eglHelper, buffer);
+            return;
+        }
+        if (!vulkanHelper.checkOptimalHardwareBuffer(reporter)) {
+            cleanup_resources(&vulkanHelper, &eglHelper, buffer);
+            return;
+        }
+    }
+
+    if (SrcType::kEGL == srcType || DstType::kEGL == dstType) {
+        if (!eglHelper.init(reporter)) {
+            cleanup_resources(&vulkanHelper, &eglHelper, buffer);
+            return;
+        }
+    }
+
+    BaseTestHelper* srcHelper = nullptr;
+    BaseTestHelper* dstHelper = nullptr;
+    if (SrcType::kVulkan == srcType) {
+        srcHelper = &vulkanHelper;
+    } else if (SrcType::kEGL ==srcType) {
+        srcHelper = &eglHelper;
+    }
+
+    if (DstType::kVulkan == dstType) {
+        dstHelper = &vulkanHelper;
+    } else {
+        SkASSERT(DstType::kEGL == dstType);
+        dstHelper = &eglHelper;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Setup SkBitmaps
+    ///////////////////////////////////////////////////////////////////////////
+
+    SkBitmap srcBitmap = make_src_bitmap();
+    SkBitmap dstBitmapEGL;
+    dstBitmapEGL.allocN32Pixels(DEV_W, DEV_H);
+    SkBitmap dstBitmapVk;
+    dstBitmapVk.allocN32Pixels(DEV_W, DEV_H);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Setup AHardwareBuffer
+    ///////////////////////////////////////////////////////////////////////////
+
+    AHardwareBuffer_Desc hwbDesc;
+    hwbDesc.width = DEV_W;
+    hwbDesc.height = DEV_H;
+    hwbDesc.layers = 1;
+    if (SrcType::kCPU == srcType) {
+        hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
+                        AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                        AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    } else {
+        hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
+                        AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER |
+                        AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+                        AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+    }
+    hwbDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+    // The following three are not used in the allocate
+    hwbDesc.stride = 0;
+    hwbDesc.rfu0= 0;
+    hwbDesc.rfu1= 0;
+
+    if (int error = AHardwareBuffer_allocate(&hwbDesc, &buffer)) {
+        ERRORF(reporter, "Failed to allocated hardware buffer, error: %d", error);
+        cleanup_resources(srcHelper, dstHelper, buffer);
+        return;
+    }
+
+    if (SrcType::kCPU == srcType) {
+        // Get actual desc for allocated buffer so we know the stride for uploading cpu data.
+        AHardwareBuffer_describe(buffer, &hwbDesc);
+
+        uint32_t* bufferAddr;
+        if (AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1, nullptr,
+                                 reinterpret_cast<void**>(&bufferAddr))) {
+            ERRORF(reporter, "Failed to lock hardware buffer");
+            cleanup_resources(srcHelper, dstHelper, buffer);
+            return;
+        }
+
+        int bbp = srcBitmap.bytesPerPixel();
+        uint32_t* src = (uint32_t*)srcBitmap.getPixels();
+        uint32_t* dst = bufferAddr;
+        for (int y = 0; y < DEV_H; ++y) {
+            memcpy(dst, src, DEV_W * bbp);
+            src += DEV_W;
+            dst += hwbDesc.stride;
+        }
+
+        for (int y = 0; y < DEV_H; ++y) {
+            for (int x = 0; x < DEV_W; ++x) {
+                const uint32_t srcPixel = *srcBitmap.getAddr32(x, y);
+                uint32_t dstPixel = bufferAddr[y * hwbDesc.stride + x];
+                if (srcPixel != dstPixel) {
+                    ERRORF(reporter, "CPU HWB Expected readpix (%d, %d) value 0x%08x, got 0x%08x.",
+                           x, y, srcPixel, dstPixel);
+                }
+            }
+        }
+
+        AHardwareBuffer_unlock(buffer, nullptr);
+
+    } else {
+        sk_sp<SkSurface> surface = srcHelper->importHardwareBufferForWrite(reporter, buffer);
+
+        if (!surface) {
+            cleanup_resources(srcHelper, dstHelper, buffer);
+            return;
+        }
+
+        sk_sp<SkImage> srcBmpImage = SkImage::MakeFromBitmap(srcBitmap);
+        surface->getCanvas()->drawImage(srcBmpImage, 0, 0);
+
+        bool readResult = surface->readPixels(dstBitmapEGL, 0, 0);
+        if (!readResult) {
+            ERRORF(reporter, "Read Pixels on surface failed");
+            surface.reset();
+            cleanup_resources(srcHelper, dstHelper, buffer);
+            return;
+        }
+
+        REPORTER_ASSERT(reporter, check_read(reporter, srcBitmap, dstBitmapEGL));
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Cleanup GL/EGL and add syncs
+        ///////////////////////////////////////////////////////////////////////////
+
+        surface.reset();
+        srcHelper->doClientSync();
+        srcHelper->releaseImage();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Import the HWB into backend and draw it to a surface
+    ///////////////////////////////////////////////////////////////////////////
+
+    sk_sp<SkImage> wrappedImage = dstHelper->importHardwareBufferForRead(reporter, buffer);
+    if (!wrappedImage) {
+        cleanup_resources(srcHelper, dstHelper, buffer);
+        return;
+    }
+
+    GrContext* grContext = dstHelper->grContext();
+
+    // Make SkSurface to render wrapped HWB into.
+    SkImageInfo imageInfo = SkImageInfo::Make(DEV_W, DEV_H, kRGBA_8888_SkColorType,
+                                              kPremul_SkAlphaType, nullptr);
+
+    sk_sp<SkSurface> dstSurf = SkSurface::MakeRenderTarget(grContext,
+                                                           SkBudgeted::kNo, imageInfo, 0,
+                                                           kTopLeft_GrSurfaceOrigin,
+                                                           nullptr, false);
+    if (!dstSurf.get()) {
+        ERRORF(reporter, "Failed to create destination SkSurface");
+        wrappedImage.reset();
+        cleanup_resources(srcHelper, dstHelper, buffer);
+        return;
+    }
+
+    dstSurf->getCanvas()->drawImage(wrappedImage, 0, 0);
+
+    bool readResult = dstSurf->readPixels(dstBitmapVk, 0, 0);
+    if (!readResult) {
+        ERRORF(reporter, "Read Pixels failed");
+        wrappedImage.reset();
+        dstHelper->doClientSync();
+        cleanup_resources(srcHelper, dstHelper, buffer);
+        return;
+    }
+
+    REPORTER_ASSERT(reporter, check_read(reporter, srcBitmap, dstBitmapVk));
+
+    wrappedImage.reset();
+    dstHelper->doClientSync();
+    cleanup_resources(srcHelper, dstHelper, buffer);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_CPU_Vulkan, reporter, options) {
+    run_test(reporter, options, SrcType::kCPU, DstType::kVulkan);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_EGL_Vulkan, reporter, options) {
+    run_test(reporter, options, SrcType::kEGL, DstType::kVulkan);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_Vulkan, reporter, options) {
+    run_test(reporter, options, SrcType::kEGL, DstType::kVulkan);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_CPU_EGL, reporter, options) {
+    run_test(reporter, options, SrcType::kCPU, DstType::kEGL);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_EGL_EGL, reporter, options) {
+    run_test(reporter, options, SrcType::kEGL, DstType::kEGL);
+}
+
+DEF_GPUTEST(VulkanHardwareBuffer_Vulkan_EGL, reporter, options) {
+    run_test(reporter, options, SrcType::kEGL, DstType::kEGL);
+}
+
+#endif
+#endif
+
diff --git a/tools/skqp/gn_to_bp.py b/tools/skqp/gn_to_bp.py
index f134e7c..822018c 100644
--- a/tools/skqp/gn_to_bp.py
+++ b/tools/skqp/gn_to_bp.py
@@ -37,6 +37,7 @@
         $cflags
         "-Wno-unused-parameter",
         "-Wno-unused-variable",
+        "-DSKQP_BUILD_HARDWAREBUFFER_TEST",
     ],
 
     cppflags:[