@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/gpu/graphite/precompile/PrecompileRuntimeEffect.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED
+#define skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+
+class SkRuntimeEffect;
+
+namespace skgpu::graphite {
+
+class PrecompileBase;
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileShader;
+
+using PrecompileChildOptions = SkSpan<const sk_sp<PrecompileBase>>;
+
+//--------------------------------------------------------------------------------------------------
+// These factory functions correspond to the main API's SkRuntimeEffect makeShader, makeColorFilter,
+// and makeBlender functions. The uniform values found in the main API are abstracted away since
+// they do not alter the generated code.
+namespace PrecompileRuntimeEffects {
+
+SK_API sk_sp<PrecompileShader> MakePrecompileShader(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+SK_API sk_sp<PrecompileColorFilter> MakePrecompileColorFilter(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+SK_API sk_sp<PrecompileBlender> MakePrecompileBlender(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+} // namespace PrecompileRuntimeEffects
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileShader.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileShader_DEFINED
+#define skgpu_graphite_precompile_PrecompileShader_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include "include/core/SkBlendMode.h"
+
+class SkColorSpace;
+
+namespace skgpu::graphite {
+
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileShaderPriv;
+
+/** \class PrecompileShader
+    This class corresponds to the SkShader class in the main API.
+*/
+class SK_API PrecompileShader : public PrecompileBase {
+public:
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithLocalMatrix. The actual matrix
+     *  involved is abstracted away, except for whether or the not the matrix involves perspective
+     *  so the correct generated shader variation is chosen.
+     *  The PrecompileShaders::LocalMatrix factory can be used to generate a set of shaders
+     *  that would've been generated via multiple makeWithLocalMatrix calls. That is, rather than
+     *  performing:
+     *     sk_sp<PrecompileShader> option1 = source1->makeWithLocalMatrix(false);
+     *     sk_sp<PrecompileShader> option2 = source2->makeWithLocalMatrix(false);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = LocalMatrix({ source1, source2 }, false);
+     */
+    sk_sp<PrecompileShader> makeWithLocalMatrix(bool isPerspective) const;
+
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithColorFilter.
+     *  The PrecompileShaders::ColorFilter factory can be used to generate a set of shaders that
+     *  would've been generated via multiple makeWithColorFilter calls. That is, rather than
+     *  performing:
+     *     sk_sp<PrecompileShader> option1 = source->makeWithColorFilter(colorFilter1);
+     *     sk_sp<PrecompileShader> option2 = source->makeWithColorFilter(colorFilter2);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source },
+     *                                                           { colorFilter1, colorFilter2 });
+     *  With an alternative use case one could also use the ColorFilter factory thusly:
+     *     sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source1, source2 },
+     *                                                           { colorFilter });
+     */
+    sk_sp<PrecompileShader> makeWithColorFilter(sk_sp<PrecompileColorFilter>) const;
+
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithWorkingColorSpace.
+     *  The PrecompileShaders::WorkingColorSpace factory can be used to generate a set of shaders
+     *  that would've been generated via multiple makeWithWorkingColorSpace calls. That is, rather
+     *  than performing:
+     *     sk_sp<PrecompileShader> option1 = source->makeWithWorkingColorSpace(colorSpace1);
+     *     sk_sp<PrecompileShader> option2 = source->makeWithWorkingColorSpace(colorSpace2);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source },
+     *                                                                 { colorSpace1,
+     *                                                                   colorSpace2 });
+     *  With an alternative use case one could also use the WorkingColorSpace factory thusly:
+     *     sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source1, source2 },
+     *                                                                 { colorSpace });
+     */
+    sk_sp<PrecompileShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace>) const;
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileShaderPriv priv();
+    const PrecompileShaderPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class PrecompileShaderPriv;
+
+    PrecompileShader() : PrecompileBase(Type::kShader) {}
+    ~PrecompileShader() override;
+
+    virtual bool isConstant(int /* desiredCombination */) const { return false; }
+
+    virtual bool isALocalMatrixShader() const { return false; }
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkShaders namespace in the main API
+namespace PrecompileShaders {
+    // --- This block of eight matches the SkShaders factories in SkShader.h
+    // Note that some of the details of the main API have been elided since they don't impact
+    // the generated shader (e.g., the color parameter to the Color() factories).
+    SK_API sk_sp<PrecompileShader> Empty();
+    SK_API sk_sp<PrecompileShader> Color();
+    SK_API sk_sp<PrecompileShader> Color(sk_sp<SkColorSpace>);
+    SK_API sk_sp<PrecompileShader> Blend(SkSpan<const SkBlendMode> blendModes,
+                                         SkSpan<const sk_sp<PrecompileShader>> dsts,
+                                         SkSpan<const sk_sp<PrecompileShader>> srcs);
+    SK_API sk_sp<PrecompileShader> Blend(SkSpan<const sk_sp<PrecompileBlender>> blenders,
+                                         SkSpan<const sk_sp<PrecompileShader>> dsts,
+                                         SkSpan<const sk_sp<PrecompileShader>> srcs);
+    SK_API sk_sp<PrecompileShader> CoordClamp(SkSpan<const sk_sp<PrecompileShader>>);
+
+    // In the main Skia API ImageShaders are usually created via a SkImage::makeShader call.
+    // Since the SkImage used to create the ImageShader is unlikely to be present at precompilation
+    // time this entry point allows the equivalent precompilation program structure to be created.
+    // Note that this factory is for non-YUV SkImages, the YUVImage factory (below) should be used
+    // to represent the shading and sampling required for YUV images.
+    SK_API sk_sp<PrecompileShader> Image();
+    // As with the above Image call, raw ImageShaders are usually created via an
+    // SkImage::makeRawShader call. The RawImage call allows the equivalent precompilation
+    // program structure to be created without needing the SkImage.
+    SK_API sk_sp<PrecompileShader> RawImage();
+
+    // In the main Skia API, the specifics of the SkImage used for the SkImage::makeShader call
+    // can determine whether normal or YUV sampling is required. This entry point allows clients
+    // to specify that the future image will be a YUV image.
+    SK_API sk_sp<PrecompileShader> YUVImage();
+
+    // --- This block of two matches the SkShaders factories in SkPerlinNoiseShader.h
+    // Again, most of the details have been elided.
+    SK_API sk_sp<PrecompileShader> MakeFractalNoise();
+    SK_API sk_sp<PrecompileShader> MakeTurbulence();
+
+    // --- This block of four matches all the factories in SkGradientShader (SkGradientShader.h)
+    SK_API sk_sp<PrecompileShader> LinearGradient();
+    SK_API sk_sp<PrecompileShader> RadialGradient();
+    SK_API sk_sp<PrecompileShader> TwoPointConicalGradient();
+    SK_API sk_sp<PrecompileShader> SweepGradient();
+
+    // Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the
+    // SkPicture to be drawn, most likely, won't be available at precompilation time, this
+    // entry point can be used to create a precompilation equivalent.
+    // Note: this will precompile the program that draws the SkPicture. It, obviously, won't
+    // precompile any SkPaints within the SkPicture.
+    SK_API sk_sp<PrecompileShader> Picture();
+
+    // Normally, LocalMatrixShaders are only created via SkShader::makeWithLocalMatrix.
+    // However, in the combination API, clients may want to create a set of precompile
+    // LocalMatrixShaders (i.e., pass an SkSpan to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithLocalMatrix() can still be used and works as expected.
+    SK_API sk_sp<PrecompileShader> LocalMatrix(SkSpan<const sk_sp<PrecompileShader>> wrapped,
+                                               bool isPerspective = false);
+
+    // Normally, ColorFilterShaders are only created via SkShader::makeWithColorFilter.
+    // However, in the combination API, clients may want to create a set of precompile
+    // ColorFilterShaders (i.e., pass SkSpans to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithColorFilter can still be used and works as expected.
+    SK_API sk_sp<PrecompileShader> ColorFilter(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const sk_sp<PrecompileColorFilter>> colorFilters);
+
+    // Normally, WorkingColorSpaceShaders are only created via SkShader::makeWithWorkingColorSpace.
+    // However, in the combination API, clients may want to create a set of precompile
+    // WorkingColorSpaceShaders (i.e., pass SkSpans to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithWorkingColorSpace can still be used and works as expected.
+    SK_API sk_sp<PrecompileShader> WorkingColorSpace(SkSpan<const sk_sp<PrecompileShader>> shaders,
+                                                     SkSpan<const sk_sp<SkColorSpace>> colorSpaces);
+
+} // namespace PrecompileShaders
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileShader_DEFINED

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -8,7 +8,9 @@
 #ifndef skgpu_graphite_VulkanGraphiteTypes_DEFINED
 #define skgpu_graphite_VulkanGraphiteTypes_DEFINED
 
+#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
 #include "include/gpu/vk/VulkanTypes.h"
 
 namespace skgpu::graphite {
@@ -57,8 +59,28 @@ struct VulkanTextureInfo {
             , fYcbcrConversionInfo(ycbcrConversionInfo) {}
 };
 
-} // namespace skgpu::graphite
+namespace TextureInfos {
+SK_API TextureInfo MakeVulkan(const VulkanTextureInfo&);
 
-#endif // skgpu_graphite_VulkanGraphiteTypes_DEFINED
+SK_API bool GetVulkanTextureInfo(const TextureInfo&, VulkanTextureInfo*);
+}  // namespace TextureInfos
 
+namespace BackendTextures {
+SK_API BackendTexture MakeVulkan(SkISize dimensions,
+                                 const VulkanTextureInfo&,
+                                 VkImageLayout,
+                                 uint32_t queueFamilyIndex,
+                                 VkImage,
+                                 VulkanAlloc);
+}  // namespace BackendTextures
 
+namespace BackendSemaphores {
+SK_API BackendSemaphore MakeVulkan(VkSemaphore);
+
+SK_API VkSemaphore GetVkSemaphore(const BackendSemaphore&);
+
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_VulkanGraphiteTypes_DEFINED

package/cpp/skia/include/gpu/mock/GrMockTypes.h

@@ -4,160 +4,5 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-#ifndef GrMockOptions_DEFINED
-#define GrMockOptions_DEFINED
-
-#include "include/core/SkTextureCompressionType.h"
-#include "include/gpu/GpuTypes.h"
-#include "include/private/gpu/ganesh/GrTypesPriv.h"
-
-class GrBackendFormat;
-
-struct GrMockTextureInfo {
-    GrMockTextureInfo()
-        : fColorType(GrColorType::kUnknown)
-        , fCompressionType(SkTextureCompressionType::kNone)
-        , fID(0) {}
-
-    GrMockTextureInfo(GrColorType colorType,
-                      SkTextureCompressionType compressionType,
-                      int id,
-                      skgpu::Protected isProtected = skgpu::Protected::kNo)
-            : fColorType(colorType)
-            , fCompressionType(compressionType)
-            , fID(id)
-            , fProtected(isProtected) {
-        SkASSERT(fID);
-        if (fCompressionType != SkTextureCompressionType::kNone) {
-            SkASSERT(colorType == GrColorType::kUnknown);
-        }
-    }
-
-    bool operator==(const GrMockTextureInfo& that) const {
-        return fColorType == that.fColorType &&
-               fCompressionType == that.fCompressionType &&
-               fID == that.fID &&
-               fProtected == that.fProtected;
-    }
-
-    GrBackendFormat getBackendFormat() const;
-
-    SkTextureCompressionType compressionType() const { return fCompressionType; }
-
-    GrColorType colorType() const {
-        SkASSERT(fCompressionType == SkTextureCompressionType::kNone);
-        return fColorType;
-    }
-
-    int id() const { return fID; }
-
-    skgpu::Protected getProtected() const { return fProtected; }
-    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
-
-private:
-    GrColorType              fColorType;
-    SkTextureCompressionType fCompressionType;
-    int                      fID;
-    skgpu::Protected         fProtected = skgpu::Protected::kNo;
-};
-
-struct GrMockRenderTargetInfo {
-    GrMockRenderTargetInfo()
-            : fColorType(GrColorType::kUnknown)
-            , fID(0) {}
-
-    GrMockRenderTargetInfo(GrColorType colorType,
-                           int id,
-                           skgpu::Protected isProtected = skgpu::Protected::kNo)
-            : fColorType(colorType)
-            , fID(id)
-            , fProtected(isProtected) {
-        SkASSERT(fID);
-    }
-
-    bool operator==(const GrMockRenderTargetInfo& that) const {
-        return fColorType == that.fColorType &&
-               fID == that.fID &&
-               fProtected == that.fProtected;
-    }
-
-    GrBackendFormat getBackendFormat() const;
-
-    GrColorType colorType() const { return fColorType; }
-
-    skgpu::Protected getProtected() const { return fProtected; }
-    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
-
-private:
-    GrColorType      fColorType;
-    int              fID;
-    skgpu::Protected fProtected = skgpu::Protected::kNo;
-};
-
-struct GrMockSurfaceInfo {
-    uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
-    skgpu::Protected fProtected = skgpu::Protected::kNo;
-
-    GrColorType fColorType = GrColorType::kUnknown;
-    SkTextureCompressionType fCompressionType = SkTextureCompressionType::kNone;
-};
-
-static constexpr int kSkTextureCompressionTypeCount =
-        static_cast<int>(SkTextureCompressionType::kLast) + 1;
-
-/**
- * A pointer to this type is used as the GrBackendContext when creating a Mock GrContext. It can be
- * used to specify capability options for the mock context. If nullptr is used a default constructed
- * GrMockOptions is used.
- */
-struct GrMockOptions {
-    GrMockOptions() {
-        using Renderability = ConfigOptions::Renderability;
-        // By default RGBA_8888 and BGRA_8888 are textureable and renderable and
-        // A8 and RGB565 are texturable.
-        fConfigOptions[(int)GrColorType::kRGBA_8888].fRenderability = Renderability::kNonMSAA;
-        fConfigOptions[(int)GrColorType::kRGBA_8888].fTexturable = true;
-        fConfigOptions[(int)GrColorType::kAlpha_8].fTexturable = true;
-        fConfigOptions[(int)GrColorType::kBGR_565].fTexturable = true;
-        fConfigOptions[(int)GrColorType::kRGB_565].fTexturable = true;
-
-        fConfigOptions[(int)GrColorType::kBGRA_8888] = fConfigOptions[(int)GrColorType::kRGBA_8888];
-
-        fCompressedOptions[(int)SkTextureCompressionType::kETC2_RGB8_UNORM].fTexturable = true;
-        fCompressedOptions[(int)SkTextureCompressionType::kBC1_RGB8_UNORM].fTexturable = true;
-        fCompressedOptions[(int)SkTextureCompressionType::kBC1_RGBA8_UNORM].fTexturable = true;
-    }
-
-    struct ConfigOptions {
-        enum Renderability { kNo, kNonMSAA, kMSAA };
-        Renderability fRenderability = kNo;
-        bool fTexturable = false;
-    };
-
-    // GrCaps options.
-    bool fMipmapSupport = false;
-    bool fDrawInstancedSupport = false;
-    bool fHalfFloatVertexAttributeSupport = false;
-    uint32_t fMapBufferFlags = 0;
-    int fMaxTextureSize = 2048;
-    int fMaxRenderTargetSize = 2048;
-    int fMaxWindowRectangles = 0;
-    int fMaxVertexAttributes = 16;
-    ConfigOptions fConfigOptions[kGrColorTypeCnt];
-    ConfigOptions fCompressedOptions[kSkTextureCompressionTypeCount];
-
-    // GrShaderCaps options.
-    bool fIntegerSupport = false;
-    bool fFlatInterpolationSupport = false;
-    int fMaxVertexSamplers = 0;
-    int fMaxFragmentSamplers = 8;
-    bool fShaderDerivativeSupport = true;
-    bool fDualSourceBlendingSupport = false;
-
-    // GrMockGpu options.
-    bool fFailTextureAllocations = false;
-};
-
-#endif
+// TODO(kjlubick, egdaniel) Delete this after migrating clients.
+#include "include/gpu/ganesh/mock/GrMockTypes.h"

package/cpp/skia/include/gpu/mtl/MtlMemoryAllocator.h

@@ -8,6 +8,8 @@
 #ifndef skgpu_MtlMemoryAllocator_DEFINED
 #define skgpu_MtlMemoryAllocator_DEFINED
 
+#include "include/core/SkRefCnt.h"
+
 #ifdef __APPLE__
 
 #ifdef __OBJC__

package/cpp/skia/include/gpu/vk/GrVkTypes.h

@@ -1,107 +1,8 @@
-
 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-#ifndef GrVkTypes_DEFINED
-#define GrVkTypes_DEFINED
-
-#include "include/gpu/GpuTypes.h"
-#include "include/gpu/vk/VulkanTypes.h"
-
-using GrVkBackendMemory = skgpu::VulkanBackendMemory;
-using GrVkAlloc = skgpu::VulkanAlloc;
-using GrVkYcbcrConversionInfo = skgpu::VulkanYcbcrConversionInfo;
-
-/*
- * When wrapping a GrBackendTexture or GrBackendRendenderTarget, the fCurrentQueueFamily should
- * either be VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_EXTERNAL, or VK_QUEUE_FAMILY_FOREIGN_EXT. If
- * fSharingMode is VK_SHARING_MODE_EXCLUSIVE then fCurrentQueueFamily can also be the graphics
- * queue index passed into Skia.
- */
-struct GrVkImageInfo {
-    VkImage                  fImage = VK_NULL_HANDLE;
-    skgpu::VulkanAlloc       fAlloc;
-    VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
-    VkImageLayout            fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-    VkFormat                 fFormat = VK_FORMAT_UNDEFINED;
-    VkImageUsageFlags        fImageUsageFlags = 0;
-    uint32_t                 fSampleCount = 1;
-    uint32_t                 fLevelCount = 0;
-    uint32_t                 fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
-    skgpu::Protected         fProtected = skgpu::Protected::kNo;
-    GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
-    VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-    bool                     fPartOfSwapchainOrAndroidWindow = false;
-#endif
-
-    bool operator==(const GrVkImageInfo& that) const {
-        bool equal = fImage == that.fImage && fAlloc == that.fAlloc &&
-                     fImageTiling == that.fImageTiling &&
-                     fImageLayout == that.fImageLayout &&
-                     fFormat == that.fFormat &&
-                     fImageUsageFlags == that.fImageUsageFlags &&
-                     fSampleCount == that.fSampleCount &&
-                     fLevelCount == that.fLevelCount &&
-                     fCurrentQueueFamily == that.fCurrentQueueFamily &&
-                     fProtected == that.fProtected &&
-                     fYcbcrConversionInfo == that.fYcbcrConversionInfo &&
-                     fSharingMode == that.fSharingMode;
-#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-        equal = equal && (fPartOfSwapchainOrAndroidWindow == that.fPartOfSwapchainOrAndroidWindow);
-#endif
-        return equal;
-    }
-};
-
-using GrVkGetProc = skgpu::VulkanGetProc;
-
-/**
- * This object is wrapped in a GrBackendDrawableInfo and passed in as an argument to
- * drawBackendGpu() calls on an SkDrawable. The drawable will use this info to inject direct
- * Vulkan calls into our stream of GPU draws.
- *
- * The SkDrawable is given a secondary VkCommandBuffer in which to record draws. The GPU backend
- * will then execute that command buffer within a render pass it is using for its own draws. The
- * drawable is also given the attachment of the color index, a compatible VkRenderPass, and the
- * VkFormat of the color attachment so that it can make VkPipeline objects for the draws. The
- * SkDrawable must not alter the state of the VkRenderpass or sub pass.
- *
- * Additionally, the SkDrawable may fill in the passed in fDrawBounds with the bounds of the draws
- * that it submits to the command buffer. This will be used by the GPU backend for setting the
- * bounds in vkCmdBeginRenderPass. If fDrawBounds is not updated, we will assume that the entire
- * attachment may have been written to.
- *
- * The SkDrawable is always allowed to create its own command buffers and submit them to the queue
- * to render offscreen textures which will be sampled in draws added to the passed in
- * VkCommandBuffer. If this is done the SkDrawable is in charge of adding the required memory
- * barriers to the queue for the sampled images since the Skia backend will not do this.
- */
-struct GrVkDrawableInfo {
-    VkCommandBuffer fSecondaryCommandBuffer;
-    uint32_t        fColorAttachmentIndex;
-    VkRenderPass    fCompatibleRenderPass;
-    VkFormat        fFormat;
-    VkRect2D*       fDrawBounds;
-#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-    bool            fFromSwapchainOrAndroidWindow;
-#endif
-};
-
-struct GrVkSurfaceInfo {
-    uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
-    skgpu::Protected fProtected = skgpu::Protected::kNo;
-
-    VkImageTiling fImageTiling = VK_IMAGE_TILING_OPTIMAL;
-    VkFormat fFormat = VK_FORMAT_UNDEFINED;
-    VkImageUsageFlags fImageUsageFlags = 0;
-    GrVkYcbcrConversionInfo fYcbcrConversionInfo;
-    VkSharingMode fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-};
-
-#endif
+// TODO(kjlubick, egdaniel) Delete this after migrating clients.
+#include "include/gpu/ganesh/vk/GrVkTypes.h"

package/cpp/skia/include/gpu/vk/VulkanBackendContext.h

@@ -8,9 +8,14 @@
 #ifndef skgpu_VulkanBackendContext_DEFINED
 #define skgpu_VulkanBackendContext_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "include/gpu/GpuTypes.h"
 #include "include/gpu/vk/VulkanMemoryAllocator.h"
 #include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
 
 namespace skgpu {
 
@@ -18,14 +23,14 @@ class VulkanExtensions;
 
 // The VkBackendContext contains all of the base Vk objects needed by the skia Vulkan context.
 struct SK_API VulkanBackendContext {
-    VkInstance                       fInstance;
-    VkPhysicalDevice                 fPhysicalDevice;
-    VkDevice                         fDevice;
-    VkQueue                          fQueue;
-    uint32_t                         fGraphicsQueueIndex;
+    VkInstance                       fInstance = VK_NULL_HANDLE;
+    VkPhysicalDevice                 fPhysicalDevice = VK_NULL_HANDLE;
+    VkDevice                         fDevice = VK_NULL_HANDLE;
+    VkQueue                          fQueue = VK_NULL_HANDLE;
+    uint32_t                         fGraphicsQueueIndex = 0;
     // The max api version set here should match the value set in VkApplicationInfo::apiVersion when
     // then VkInstance was created.
-    uint32_t                         fMaxAPIVersion;
+    uint32_t                         fMaxAPIVersion = 0;
     const skgpu::VulkanExtensions*   fVkExtensions = nullptr;
     // The client can create their VkDevice with either a VkPhysicalDeviceFeatures or
     // VkPhysicalDeviceFeatures2 struct, thus we have to support taking both. The
@@ -38,7 +43,7 @@ struct SK_API VulkanBackendContext {
     // for allocating Vulkan resources that use VkDeviceMemory.
     sk_sp<VulkanMemoryAllocator>     fMemoryAllocator;
     skgpu::VulkanGetProc             fGetProc;
-    Protected                        fProtectedContext;
+    Protected                        fProtectedContext = Protected::kNo;
     // Optional callback which will be invoked if a VK_ERROR_DEVICE_LOST error code is received from
     // the driver. Debug information from the driver will be provided to the callback if the
     // VK_EXT_device_fault extension is supported and enabled (VkPhysicalDeviceFaultFeaturesEXT must
@@ -47,6 +52,6 @@ struct SK_API VulkanBackendContext {
     skgpu::VulkanDeviceLostProc      fDeviceLostProc = nullptr;
 };
 
-} // namespace skgpu::graphite
+}  // namespace skgpu
 
 #endif // skgpu_VulkanBackendContext_DEFINED

package/cpp/skia/include/gpu/vk/VulkanExtensions.h

@@ -10,7 +10,13 @@
 
 #include "include/core/SkString.h"
 #include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTArray.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+#include <cstring>
 
 namespace skgpu {
 
@@ -37,10 +43,10 @@ public:
 
         struct Less {
             bool operator()(const Info& a, const SkString& b) const {
-                return strcmp(a.fName.c_str(), b.c_str()) < 0;
+                return std::strcmp(a.fName.c_str(), b.c_str()) < 0;
             }
             bool operator()(const SkString& a, const VulkanExtensions::Info& b) const {
-                return strcmp(a.c_str(), b.fName.c_str()) < 0;
+                return std::strcmp(a.c_str(), b.fName.c_str()) < 0;
             }
         };
     };
@@ -49,7 +55,7 @@ public:
     void dump() const {
         SkDebugf("**Vulkan Extensions**\n");
         for (int i = 0; i < fExtensions.size(); ++i) {
-            SkDebugf("%s. Version: %d\n",
+            SkDebugf("%s. Version: %u\n",
                      fExtensions[i].fName.c_str(), fExtensions[i].fSpecVersion);
         }
         SkDebugf("**End Vulkan Extensions**\n");

package/cpp/skia/include/gpu/vk/VulkanMemoryAllocator.h

@@ -9,8 +9,11 @@
 #define skgpu_VulkanMemoryAllocator_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GpuTypes.h"
 #include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+#include <utility>
 
 namespace skgpu {