@shopify/react-native-skia 1.3.13 → 1.4.1

package/cpp/skia/include/gpu/ganesh/gl/GrGLMakeWebGLInterface.h

@@ -0,0 +1,19 @@
+/*
+ * 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 GrGLMakeWebGLInterface_DEFINED
+#define GrGLMakeWebGLInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeWebGL();
+}
+
+#endif  // GrGLMakeWebGLInterface_DEFINED

package/cpp/skia/include/gpu/ganesh/gl/GrGLTypes.h

@@ -0,0 +1,219 @@
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLTypes_DEFINED
+#define GrGLTypes_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/gl/GrGLConfig.h"
+
+/**
+ * Classifies GL contexts by which standard they implement (currently as OpenGL vs. OpenGL ES).
+ */
+enum GrGLStandard {
+    kNone_GrGLStandard,
+    kGL_GrGLStandard,
+    kGLES_GrGLStandard,
+    kWebGL_GrGLStandard,
+};
+static const int kGrGLStandardCnt = 4;
+
+// The following allow certain interfaces to be turned off at compile time
+// (for example, to lower code size).
+#if SK_ASSUME_GL_ES
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) true
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_GL
+    #define GR_IS_GR_GL(standard) true
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_WEBGL
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) true
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_GL_INTERFACE 1
+#else
+    #define GR_IS_GR_GL(standard) (kGL_GrGLStandard == standard)
+    #define GR_IS_GR_GL_ES(standard) (kGLES_GrGLStandard == standard)
+    #define GR_IS_GR_WEBGL(standard) (kWebGL_GrGLStandard == standard)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The supported GL formats represented as an enum. Actual support by GrContext depends on GL
+ * context version and extensions.
+ */
+enum class GrGLFormat {
+    kUnknown,
+
+    kRGBA8,
+    kR8,
+    kALPHA8,
+    kLUMINANCE8,
+    kLUMINANCE8_ALPHA8,
+    kBGRA8,
+    kRGB565,
+    kRGBA16F,
+    kR16F,
+    kRGB8,
+    kRGBX8,
+    kRG8,
+    kRGB10_A2,
+    kRGBA4,
+    kSRGB8_ALPHA8,
+    kCOMPRESSED_ETC1_RGB8,
+    kCOMPRESSED_RGB8_ETC2,
+    kCOMPRESSED_RGB8_BC1,
+    kCOMPRESSED_RGBA8_BC1,
+    kR16,
+    kRG16,
+    kRGBA16,
+    kRG16F,
+    kLUMINANCE16F,
+
+    kLastColorFormat = kLUMINANCE16F,
+
+    // Depth/Stencil formats
+    kSTENCIL_INDEX8,
+    kSTENCIL_INDEX16,
+    kDEPTH24_STENCIL8,
+
+    kLast = kDEPTH24_STENCIL8
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Declares typedefs for all the GL functions used in GrGLInterface
+ */
+
+typedef unsigned int GrGLenum;
+typedef unsigned char GrGLboolean;
+typedef unsigned int GrGLbitfield;
+typedef signed char GrGLbyte;
+typedef char GrGLchar;
+typedef short GrGLshort;
+typedef int GrGLint;
+typedef int GrGLsizei;
+typedef int64_t GrGLint64;
+typedef unsigned char GrGLubyte;
+typedef unsigned short GrGLushort;
+typedef unsigned int GrGLuint;
+typedef uint64_t GrGLuint64;
+typedef unsigned short int GrGLhalf;
+typedef float GrGLfloat;
+typedef float GrGLclampf;
+typedef double GrGLdouble;
+typedef double GrGLclampd;
+typedef void GrGLvoid;
+#ifdef _WIN64
+typedef signed long long int GrGLintptr;
+typedef signed long long int GrGLsizeiptr;
+#else
+typedef signed long int GrGLintptr;
+typedef signed long int GrGLsizeiptr;
+#endif
+typedef void* GrGLeglImage;
+typedef struct __GLsync* GrGLsync;
+
+struct GrGLDrawArraysIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirst;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+// static_asserts must have messages in this file because its included in C++14 client code.
+static_assert(16 == sizeof(GrGLDrawArraysIndirectCommand), "");
+
+struct GrGLDrawElementsIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirstIndex;
+    GrGLuint fBaseVertex;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+static_assert(20 == sizeof(GrGLDrawElementsIndirectCommand), "");
+
+/**
+ * KHR_debug
+ */
+typedef void (GR_GL_FUNCTION_TYPE* GRGLDEBUGPROC)(GrGLenum source,
+                                                  GrGLenum type,
+                                                  GrGLuint id,
+                                                  GrGLenum severity,
+                                                  GrGLsizei length,
+                                                  const GrGLchar* message,
+                                                  const void* userParam);
+
+/**
+ * EGL types.
+ */
+typedef void* GrEGLImage;
+typedef void* GrEGLDisplay;
+typedef void* GrEGLContext;
+typedef void* GrEGLClientBuffer;
+typedef unsigned int GrEGLenum;
+typedef int32_t GrEGLint;
+typedef unsigned int GrEGLBoolean;
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Types for interacting with GL resources created externally to Skia. GrBackendObjects for GL
+ * textures are really const GrGLTexture*. The fFormat here should be a sized, internal format
+ * for the texture. We will try to use the sized format if the GL Context supports it, otherwise
+ * we will internally fall back to using the base internal formats.
+ */
+struct GrGLTextureInfo {
+    GrGLenum fTarget;
+    GrGLuint fID;
+    GrGLenum fFormat = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    bool operator==(const GrGLTextureInfo& that) const {
+        return fTarget == that.fTarget &&
+               fID == that.fID &&
+               fFormat == that.fFormat &&
+               fProtected == that.fProtected;
+    }
+
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+};
+
+struct GrGLFramebufferInfo {
+    GrGLuint fFBOID;
+    GrGLenum fFormat = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    bool operator==(const GrGLFramebufferInfo& that) const {
+        return fFBOID == that.fFBOID &&
+               fFormat == that.fFormat &&
+               fProtected == that.fProtected;
+    }
+
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+};
+
+struct GrGLSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    GrGLenum fTarget = 0;
+    GrGLenum fFormat = 0;
+};
+
+#endif

package/cpp/skia/include/gpu/{gl → ganesh/gl}/egl/GrGLMakeEGLInterface.h

@@ -8,7 +8,7 @@
 #define GrGLMakeEGLInterface_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
 struct GrGLInterface;
 
@@ -16,7 +16,7 @@ namespace GrGLInterfaces {
 SK_API sk_sp<const GrGLInterface> MakeEGL();
 }
 
-#if !defined(SK_DISABLE_LEGACY_GLXINTERFACE_FACTORY)
+#if !defined(SK_DISABLE_LEGACY_EGLINTERFACE_FACTORY)
 sk_sp<const GrGLInterface> GrGLMakeEGLInterface();
 #endif
 

package/cpp/skia/include/gpu/ganesh/gl/epoxy/GrGLMakeEpoxyEGLInterface.h

@@ -0,0 +1,20 @@
+/*
+ * 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 GrGLMakeEpoxyEGLInterface_DEFINED
+#define GrGLMakeEpoxyEGLInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeEpoxyEGL();
+}
+
+#endif  // GrGLMakeEpoxyEGLInterface_DEFINED

package/cpp/skia/include/gpu/ganesh/gl/ios/GrGLMakeIOSInterface.h

@@ -0,0 +1,20 @@
+/*
+ * 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 GrGLMakeIOSInterface_DEFINED
+#define GrGLMakeIOSInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeIOS();
+}
+
+#endif  // GrGLMakeIOSInterface_DEFINED

package/cpp/skia/include/gpu/ganesh/gl/mac/GrGLMakeMacInterface.h

@@ -0,0 +1,20 @@
+/*
+ * 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 GrGLMakeMacInterface_DEFINED
+#define GrGLMakeMacInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeMac();
+}
+
+#endif  // GrGLMakeMacInterface_DEFINED

package/cpp/skia/include/gpu/ganesh/gl/win/GrGLMakeWinInterface.h

@@ -0,0 +1,20 @@
+/*
+ * 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 GrGLMakeWinInterface_DEFINED
+#define GrGLMakeWinInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeWin();
+}
+
+#endif  // GrGLMakeWinInterface_DEFINED

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

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * 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/base/SkAssert.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
+
+#include <cstdint>
+
+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

package/cpp/skia/include/gpu/{mtl → ganesh/mtl}/GrMtlBackendContext.h

@@ -8,14 +8,14 @@
 #ifndef GrMtlBackendContext_DEFINED
 #define GrMtlBackendContext_DEFINED
 
-#include "include/gpu/mtl/GrMtlTypes.h"
+#include "include/gpu/ganesh/mtl/GrMtlTypes.h"
+#include "include/ports/SkCFObject.h"
 
 // The BackendContext contains all of the base Metal objects needed by the GrMtlGpu. The assumption
 // is that the client will set these up and pass them to the GrMtlGpu constructor.
 struct SK_API GrMtlBackendContext {
     sk_cfp<GrMTLHandle> fDevice;
     sk_cfp<GrMTLHandle> fQueue;
-    sk_cfp<GrMTLHandle> fBinaryArchive;
 };
 
 #endif

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlBackendSemaphore.h

@@ -0,0 +1,23 @@
+/*
+ * 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 GrMtlBackendSemaphore_DEFINED
+#define GrMtlBackendSemaphore_DEFINED
+
+#include "include/gpu/ganesh/GrBackendSemaphore.h"
+#include "include/gpu/ganesh/mtl/GrMtlTypes.h"
+#include "include/private/base/SkAPI.h"
+
+namespace GrBackendSemaphores {
+// It is the creator's responsibility to ref the MTLEvent passed in here, via __bridge_retained.
+// The other end will wrap this BackendSemaphore and take the ref, via __bridge_transfer.
+SK_API GrBackendSemaphore MakeMtl(GrMTLHandle event, uint64_t value);
+SK_API GrMTLHandle GetMtlHandle(const GrBackendSemaphore&);
+SK_API uint64_t GetMtlValue(const GrBackendSemaphore&);
+}  // namespace GrBackendSemaphores
+
+#endif

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlBackendSurface.h

@@ -0,0 +1,44 @@
+/*
+ * 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 GrMtlBackendSurface_DEFINED
+#define GrMtlBackendSurface_DEFINED
+
+#include "include/gpu/ganesh/mtl/GrMtlTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <string_view>
+
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
+
+namespace GrBackendFormats {
+SK_API GrBackendFormat MakeMtl(GrMTLPixelFormat format);
+
+SK_API GrMTLPixelFormat AsMtlFormat(const GrBackendFormat&);
+
+}  // namespace GrBackendFormats
+
+namespace GrBackendTextures {
+SK_API GrBackendTexture MakeMtl(int width,
+                                int height,
+                                skgpu::Mipmapped,
+                                const GrMtlTextureInfo& mtlInfo,
+                                std::string_view label = {});
+
+SK_API bool GetMtlTextureInfo(const GrBackendTexture&, GrMtlTextureInfo*);
+
+}  // namespace GrBackendTextures
+
+namespace GrBackendRenderTargets {
+SK_API GrBackendRenderTarget MakeMtl(int width, int height, const GrMtlTextureInfo& mtlInfo);
+
+SK_API bool GetMtlTextureInfo(const GrBackendRenderTarget&, GrMtlTextureInfo*);
+
+}  // namespace GrBackendRenderTargets
+
+#endif

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlDirectContext.h

@@ -0,0 +1,30 @@
+/*
+ * 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 GrMtlDirectContext_DEFINED
+#define GrMtlDirectContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class GrDirectContext;
+struct GrContextOptions;
+struct GrMtlBackendContext;
+
+namespace GrDirectContexts {
+/**
+ * Makes a GrDirectContext which uses Metal as the backend. The GrMtlBackendContext contains a
+ * MTLDevice and MTLCommandQueue which should be used by the backend. These objects must
+ * have their own ref which will be released when the GrMtlBackendContext is destroyed.
+ * Ganesh will take its own ref on the objects which will be released when the GrDirectContext
+ * is destroyed.
+ */
+SK_API sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&, const GrContextOptions&);
+SK_API sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&);
+}  // namespace GrDirectContexts
+
+#endif

package/cpp/skia/include/gpu/{mtl → ganesh/mtl}/GrMtlTypes.h

@@ -41,9 +41,7 @@ public:
 
     sk_cfp<GrMTLHandle> fTexture;
 
-    bool operator==(const GrMtlTextureInfo& that) const {
-        return fTexture == that.fTexture;
-    }
+    bool operator==(const GrMtlTextureInfo& that) const { return fTexture == that.fTexture; }
 };
 
 struct GrMtlSurfaceInfo {

package/cpp/skia/include/gpu/ganesh/mtl/SkSurfaceMetal.h

@@ -10,9 +10,9 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSurface.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/gpu/ganesh/SkSurfaceGanesh.h"
-#include "include/gpu/mtl/GrMtlTypes.h"
+#include "include/gpu/ganesh/mtl/GrMtlTypes.h"
 
 namespace SkSurfaces {
 /** Creates SkSurface from CAMetalLayer.

package/cpp/skia/include/gpu/ganesh/vk/GrBackendDrawableInfo.h

@@ -8,9 +8,9 @@
 #ifndef GrBackendDrawableInfo_DEFINED
 #define GrBackendDrawableInfo_DEFINED
 
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
-#include "include/gpu/vk/GrVkTypes.h"
+#include "include/gpu/ganesh/vk/GrVkTypes.h"
 
 // If necessary, this could be pulled into a generic interface, but at this point, we only expect
 // it to be used by the Ganesh Vulkan backend.

package/cpp/skia/include/gpu/ganesh/vk/GrVkBackendSemaphore.h

@@ -8,7 +8,7 @@
 #ifndef GrVkBackendSemaphore_DEFINED
 #define GrVkBackendSemaphore_DEFINED
 
-#include "include/gpu/GrBackendSemaphore.h"
+#include "include/gpu/ganesh/GrBackendSemaphore.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/gpu/vk/SkiaVulkan.h"