@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/skia/include/private/chromium/Slug.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef sktext_gpu_Slug_DEFINED
+#define sktext_gpu_Slug_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+
+class SkCanvas;
+class SkMatrix;
+class SkPaint;
+class SkTextBlob;
+class SkReadBuffer;
+class SkStrikeClient;
+class SkWriteBuffer;
+
+namespace sktext::gpu {
+
+// You can use Slug to simulate drawTextBlob by defining the following at compile time.
+//    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG
+// You can use Slug serialization to simulate drawTextBlob by defining the following:
+//    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE
+// For Skia, add this to your args.gn file.
+//    extra_cflags = ["-D", "SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG"]
+
+// Slug encapsulates an SkTextBlob at a specific origin, using a specific paint. It can be
+// manipulated using matrix and clip changes to the canvas. If the canvas is transformed, then
+// the Slug will also transform with smaller glyphs using bi-linear interpolation to render. You
+// can think of a Slug as making a rubber stamp out of a SkTextBlob.
+class SK_API Slug : public SkRefCnt {
+public:
+    // Return nullptr if the blob would not draw. This is not because of clipping, but because of
+    // some paint optimization. The Slug is captured as if drawn using drawTextBlob.
+    static sk_sp<Slug> ConvertBlob(
+            SkCanvas* canvas, const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
+
+    // Serialize the slug.
+    sk_sp<SkData> serialize() const;
+    size_t serialize(void* buffer, size_t size) const;
+
+    // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
+    // is needed.
+    static sk_sp<Slug> Deserialize(
+            const void* data, size_t size, const SkStrikeClient* client = nullptr);
+    static sk_sp<Slug> MakeFromBuffer(SkReadBuffer& buffer);
+
+
+    // Draw the Slug obeying the canvas's mapping and clipping.
+    void draw(SkCanvas* canvas) const;
+
+    virtual SkRect sourceBounds() const = 0;
+    virtual SkRect sourceBoundsWithOrigin () const = 0;
+
+    // The paint passed into ConvertBlob; this paint is used instead of the paint resulting from
+    // the call to aboutToDraw because when we call draw(), the initial paint is needed to call
+    // aboutToDraw again to get the layer right.
+    virtual const SkPaint& initialPaint() const = 0;
+
+    virtual void doFlatten(SkWriteBuffer&) const = 0;
+
+    uint32_t uniqueID() const { return fUniqueID; }
+
+private:
+    static uint32_t NextUniqueID();
+    const uint32_t  fUniqueID{NextUniqueID()};
+};
+
+}  // namespace sktext::gpu
+
+#endif  // sktext_gpu_Slug_DEFINED

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -135,6 +135,11 @@ struct GrMipLevel {
     size_t fRowBytes = 0;
     // This may be used to keep fPixels from being freed while a GrMipLevel exists.
     sk_sp<SkData> fOptionalStorage;
+
+    static_assert(::sk_is_trivially_relocatable<decltype(fPixels)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fOptionalStorage)>::value);
+
+    using sk_is_trivially_relocatable = std::true_type;
 };
 
 enum class GrSemaphoreWrapType {
@@ -410,7 +415,7 @@ enum class GrGpuBufferType {
     kXferGpuToCpu,
     kUniform,
 };
-static const int kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kUniform) + 1;
+static const constexpr int kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kUniform) + 1;
 
 /**
  * Provides a performance hint regarding the frequency at which a data store will be accessed.

package/cpp/skia/include/private/gpu/ganesh/GrVkTypesPriv.h

@@ -11,7 +11,10 @@
 #include "include/core/SkRefCnt.h"
 #include "include/gpu/vk/GrVkTypes.h"
 
-class GrBackendSurfaceMutableStateImpl;
+namespace skgpu {
+class MutableTextureStateRef;
+}
+
 
 // This struct is to used to store the the actual information about the vulkan backend image on the
 // GrBackendTexture and GrBackendRenderTarget. When a client calls getVkImageInfo on a
@@ -30,7 +33,7 @@ struct GrVkBackendSurfaceInfo {
     // attempt to unref the old fLayout on this object.
     void assign(const GrVkBackendSurfaceInfo&, bool isValid);
 
-    GrVkImageInfo snapImageInfo(const GrBackendSurfaceMutableStateImpl*) const;
+    GrVkImageInfo snapImageInfo(const skgpu::MutableTextureStateRef*) const;
 
     bool isProtected() const { return fImageInfo.fProtected == GrProtected::kYes; }
 #if GR_TEST_UTILS
@@ -41,43 +44,6 @@ private:
     GrVkImageInfo    fImageInfo;
 };
 
-class GrVkSharedImageInfo {
-public:
-    GrVkSharedImageInfo(VkImageLayout layout, uint32_t queueFamilyIndex)
-            : fLayout(layout)
-            , fQueueFamilyIndex(queueFamilyIndex) {}
-
-    GrVkSharedImageInfo& operator=(const GrVkSharedImageInfo& that) {
-        fLayout = that.getImageLayout();
-        fQueueFamilyIndex = that.getQueueFamilyIndex();
-        return *this;
-    }
-
-     void setImageLayout(VkImageLayout layout) {
-        // Defaulting to use std::memory_order_seq_cst
-        fLayout.store(layout);
-    }
-
-    VkImageLayout getImageLayout() const {
-        // Defaulting to use std::memory_order_seq_cst
-        return fLayout.load();
-    }
-
-    void setQueueFamilyIndex(uint32_t queueFamilyIndex) {
-        // Defaulting to use std::memory_order_seq_cst
-        fQueueFamilyIndex.store(queueFamilyIndex);
-    }
-
-    uint32_t getQueueFamilyIndex() const {
-        // Defaulting to use std::memory_order_seq_cst
-        return fQueueFamilyIndex.load();
-    }
-
-private:
-    std::atomic<VkImageLayout> fLayout;
-    std::atomic<uint32_t> fQueueFamilyIndex;
-};
-
 struct GrVkImageSpec {
     GrVkImageSpec()
             : fImageTiling(VK_IMAGE_TILING_OPTIMAL)

package/cpp/skia/include/private/gpu/graphite/VulkanGraphiteTypesPriv.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2022 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_VulkanGraphiteTypesPriv_DEFINED
+#define skgpu_graphite_VulkanGraphiteTypesPriv_DEFINED
+
+#include "include/gpu/graphite/vk/VulkanGraphiteTypes.h"
+
+namespace skgpu::graphite {
+
+struct VulkanTextureSpec {
+    VulkanTextureSpec()
+            : fFlags(0)
+            , fFormat(VK_FORMAT_UNDEFINED)
+            , fImageTiling(VK_IMAGE_TILING_OPTIMAL)
+            , fImageUsageFlags(0)
+            , fSharingMode(VK_SHARING_MODE_EXCLUSIVE)
+            , fCurrentQueueFamily(VK_QUEUE_FAMILY_IGNORED)
+            , fImageLayout(VK_IMAGE_LAYOUT_UNDEFINED)
+            , fAspectMask(VK_IMAGE_ASPECT_COLOR_BIT) {}
+    VulkanTextureSpec(const VulkanTextureInfo& info)
+            : fFlags(info.fFlags)
+            , fFormat(info.fFormat)
+            , fImageTiling(info.fImageTiling)
+            , fImageUsageFlags(info.fImageUsageFlags)
+            , fSharingMode(info.fSharingMode)
+            , fCurrentQueueFamily(info.fCurrentQueueFamily)
+            , fImageLayout(info.fImageLayout)
+            , fAspectMask(info.fAspectMask) {}
+
+    bool operator==(const VulkanTextureSpec& that) const {
+        return fFlags == that.fFlags &&
+               fFormat == that.fFormat &&
+               fImageTiling == that.fImageTiling &&
+               fImageUsageFlags == that.fImageUsageFlags &&
+               fSharingMode == that.fSharingMode &&
+               fCurrentQueueFamily == that.fCurrentQueueFamily &&
+               fImageLayout == that.fImageLayout &&
+               fAspectMask == that.fAspectMask;
+    }
+
+    VkImageCreateFlags       fFlags;
+    VkFormat                 fFormat;
+    VkImageTiling            fImageTiling;
+    VkImageUsageFlags        fImageUsageFlags;
+    VkSharingMode            fSharingMode;
+    uint32_t                 fCurrentQueueFamily;
+    VkImageLayout            fImageLayout;
+    VkImageAspectFlags       fAspectMask;
+    // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+};
+
+VulkanTextureInfo VulkanTextureSpecToTextureInfo(const VulkanTextureSpec& vkSpec,
+                                                 uint32_t sampleCount,
+                                                 uint32_t levelCount);
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_VulkanGraphiteTypesPriv_DEFINED

package/cpp/skia/include/{gpu/vk/GrVkVulkan.h → private/gpu/vk/SkiaVulkan.h}

@@ -5,8 +5,8 @@
  * found in the LICENSE file.
  */
 
-#ifndef GrVkVulkan_DEFINED
-#define GrVkVulkan_DEFINED
+#ifndef SkiaVulkan_DEFINED
+#define SkiaVulkan_DEFINED
 
 #include "include/core/SkTypes.h"
 

package/cpp/skia/include/private/gpu/vk/VulkanTypesPriv.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_VulkanTypesPriv_DEFINED
+#define skgpu_VulkanTypesPriv_DEFINED
+
+#include "include/gpu/vk/VulkanTypes.h"
+
+#include <atomic>
+
+namespace skgpu {
+
+class VulkanMutableTextureState {
+public:
+    VulkanMutableTextureState(VkImageLayout layout, uint32_t queueFamilyIndex)
+            : fLayout(layout)
+            , fQueueFamilyIndex(queueFamilyIndex) {}
+
+    VulkanMutableTextureState& operator=(const VulkanMutableTextureState& that) {
+        fLayout = that.getImageLayout();
+        fQueueFamilyIndex = that.getQueueFamilyIndex();
+        return *this;
+    }
+
+     void setImageLayout(VkImageLayout layout) {
+        // Defaulting to use std::memory_order_seq_cst
+        fLayout.store(layout);
+    }
+
+    VkImageLayout getImageLayout() const {
+        // Defaulting to use std::memory_order_seq_cst
+        return fLayout.load();
+    }
+
+    void setQueueFamilyIndex(uint32_t queueFamilyIndex) {
+        // Defaulting to use std::memory_order_seq_cst
+        fQueueFamilyIndex.store(queueFamilyIndex);
+    }
+
+    uint32_t getQueueFamilyIndex() const {
+        // Defaulting to use std::memory_order_seq_cst
+        return fQueueFamilyIndex.load();
+    }
+
+private:
+    std::atomic<VkImageLayout> fLayout;
+    std::atomic<uint32_t> fQueueFamilyIndex;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanGraphiteTypesPriv_DEFINED
+

package/cpp/skia/include/sksl/DSL.h

@@ -29,7 +29,6 @@ using Modifiers = DSLModifiers;
 using Parameter = DSLParameter;
 using Statement = DSLStatement;
 using Var = DSLVar;
-template<typename T> using Wrapper = DSLWrapper<T>;
 
 } // namespace dsl
 

package/cpp/skia/include/sksl/DSLBlock.h

@@ -14,7 +14,6 @@
 #include "include/sksl/SkSLPosition.h"
 
 #include <memory>
-#include <utility>
 
 namespace SkSL {
 
@@ -28,29 +27,19 @@ public:
     template<class... Statements>
     DSLBlock(Statements... statements) {
         fStatements.reserve_back(sizeof...(statements));
-        // in C++17, we could just do:
-        // (fStatements.push_back(DSLStatement(statements.release()).release()), ...);
-        int unused[] =
-            {0,
-            (static_cast<void>(fStatements.push_back(DSLStatement(statements.release()).release())),
-             0)...};
-        static_cast<void>(unused);
+        ((void)fStatements.push_back(DSLStatement(statements.release()).release()), ...);
     }
 
-    DSLBlock(DSLBlock&& other) = default;
-
     DSLBlock(SkSL::StatementArray statements, std::shared_ptr<SymbolTable> symbols = nullptr,
             Position pos = {});
 
     DSLBlock(SkTArray<DSLStatement> statements, std::shared_ptr<SymbolTable> symbols = nullptr,
             Position pos = {});
 
-    ~DSLBlock();
+    DSLBlock(DSLBlock&& other) = default;
+    DSLBlock& operator=(DSLBlock&& other) = default;
 
-    DSLBlock& operator=(DSLBlock&& other) {
-        fStatements = std::move(other.fStatements);
-        return *this;
-    }
+    ~DSLBlock() = default;
 
     void append(DSLStatement stmt);
 
@@ -60,9 +49,6 @@ private:
     SkSL::StatementArray fStatements;
     std::shared_ptr<SkSL::SymbolTable> fSymbols;
     Position fPosition;
-
-    friend class DSLStatement;
-    friend class DSLFunction;
 };
 
 } // namespace dsl

package/cpp/skia/include/sksl/DSLCase.h

@@ -27,13 +27,7 @@ public:
     DSLCase(DSLExpression value, Statements... statements)
         : fValue(std::move(value)) {
         fStatements.reserve_back(sizeof...(statements));
-        // in C++17, we could just do:
-        // (fStatements.push_back(DSLStatement(std::move(statements)).release()), ...);
-        int unused[] =
-          {0,
-           (static_cast<void>(fStatements.push_back(DSLStatement(std::move(statements)).release())),
-            0)...};
-        static_cast<void>(unused);
+        ((void)fStatements.push_back(DSLStatement(std::move(statements)).release()), ...);
     }
 
     DSLCase(DSLExpression value, SkTArray<DSLStatement> statements,
@@ -58,7 +52,7 @@ private:
     friend class DSLCore;
 
     template<class... Cases>
-    friend DSLPossibleStatement Switch(DSLExpression value, Cases... cases);
+    friend DSLStatement Switch(DSLExpression value, Cases... cases);
 };
 
 } // namespace dsl

package/cpp/skia/include/sksl/DSLCore.h

@@ -15,6 +15,7 @@
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLStatement.h"
 #include "include/sksl/DSLVar.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <memory>
 #include <string>
@@ -25,8 +26,6 @@ namespace SkSL {
 
 class Compiler;
 class ErrorReporter;
-class Position;
-struct ForLoopPositions;
 struct Program;
 struct ProgramSettings;
 
@@ -58,7 +57,7 @@ void End();
 /**
  * Returns all global elements (functions and global variables) as a self-contained Program. The
  * optional source string is retained as the program's source. DSL programs do not normally have
- * sources, but when a DSL program is produced from parsed program text (as in DSLParser), it may be
+ * sources, but when a DSL program is produced from parsed program text (as in Parser), it may be
  * important to retain it so that any std::string_views derived from it remain valid.
  */
 std::unique_ptr<SkSL::Program> ReleaseProgram(std::unique_ptr<std::string> source = nullptr);
@@ -171,37 +170,31 @@ DSLStatement StaticIf(DSLExpression test, DSLStatement ifTrue,
                       Position pos = {});
 
 // Internal use only
-DSLPossibleStatement PossibleStaticSwitch(DSLExpression value, SkTArray<DSLCase> cases);
-
-DSLStatement StaticSwitch(DSLExpression value, SkTArray<DSLCase> cases,
-                          Position pos = {});
+DSLStatement StaticSwitch(DSLExpression value, SkTArray<DSLCase> cases, Position pos = {});
 
 /**
  * @switch (value) { cases }
  */
 template<class... Cases>
-DSLPossibleStatement StaticSwitch(DSLExpression value, Cases... cases) {
+DSLStatement StaticSwitch(DSLExpression value, Cases... cases) {
     SkTArray<DSLCase> caseArray;
     caseArray.reserve_back(sizeof...(cases));
     (caseArray.push_back(std::move(cases)), ...);
-    return PossibleStaticSwitch(std::move(value), std::move(caseArray));
+    return StaticSwitch(std::move(value), std::move(caseArray), Position{});
 }
 
 // Internal use only
-DSLPossibleStatement PossibleSwitch(DSLExpression value, SkTArray<DSLCase> cases);
-
-DSLStatement Switch(DSLExpression value, SkTArray<DSLCase> cases,
-                    Position pos = {});
+DSLStatement Switch(DSLExpression value, SkTArray<DSLCase> cases, Position pos = {});
 
 /**
  * switch (value) { cases }
  */
 template<class... Cases>
-DSLPossibleStatement Switch(DSLExpression value, Cases... cases) {
+DSLStatement Switch(DSLExpression value, Cases... cases) {
     SkTArray<DSLCase> caseArray;
     caseArray.reserve_back(sizeof...(cases));
     (caseArray.push_back(std::move(cases)), ...);
-    return PossibleSwitch(std::move(value), std::move(caseArray));
+    return Switch(std::move(value), std::move(caseArray), Position{});
 }
 
 /**