@shopify/react-native-skia 2.0.0-next.2 → 2.0.0-next.4

package/android/build.gradle

@@ -295,13 +295,17 @@ afterEvaluate { project ->
     }
 }
 
+def localBuildDir = buildDir
+def headersConfiguration = configurations.extractHeaders
+def jniConfiguration = configurations.extractJNI
+
 task extractAARHeaders {
     doLast {
-        configurations.extractHeaders.files.each {
-            def file = it.absoluteFile
-            copy {
-                from zipTree(file)
-                into "$buildDir/$file.name"
+        headersConfiguration.files.each { file ->
+            def absFile = file.absoluteFile
+            project.copy {
+                from project.zipTree(absFile)
+                into "${localBuildDir}/${absFile.name}"
                 include "**/*.h"
             }
         }
@@ -310,11 +314,11 @@ task extractAARHeaders {
 
 task extractJNIFiles {
     doLast {
-        configurations.extractJNI.files.each {
-            def file = it.absoluteFile
-            copy {
-                from zipTree(file)
-                into "$buildDir/$file.name"
+        jniConfiguration.files.each { file ->
+            def absFile = file.absoluteFile
+            project.copy {
+                from project.zipTree(absFile)
+                into "${localBuildDir}/${absFile.name}"
                 include "jni/**/*"
             }
         }

package/cpp/api/JsiSkCanvas.h

@@ -243,6 +243,12 @@ public:
 
     auto jsiPoints = arguments[1].asObject(runtime).asArray(runtime);
     auto pointsSize = jsiPoints.size(runtime);
+    
+    // Check if we have at least one point
+    if (pointsSize == 0) {
+      throw std::invalid_argument("Points array must not be empty");
+    }
+    
     points.reserve(pointsSize);
 
     for (int i = 0; i < pointsSize; i++) {
@@ -274,6 +280,12 @@ public:
 
     auto jsiCubics = arguments[0].asObject(runtime).asArray(runtime);
     auto cubicsSize = jsiCubics.size(runtime);
+    
+    // Validate cubic points - must be exactly 12 points
+    if (cubicsSize != 12) {
+      throw std::invalid_argument("Cubic points array must contain exactly 12 points");
+    }
+    
     cubics.reserve(cubicsSize);
     for (int i = 0; i < cubicsSize; i++) {
       std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
@@ -284,6 +296,12 @@ public:
     if (count >= 2 && !arguments[1].isNull() && !arguments[1].isUndefined()) {
       auto jsiColors = arguments[1].asObject(runtime).asArray(runtime);
       auto colorsSize = jsiColors.size(runtime);
+      
+      // Validate colors array - must be exactly 4 colors
+      if (colorsSize != 4) {
+        throw std::invalid_argument("Colors array must contain exactly 4 colors");
+      }
+      
       colors.reserve(colorsSize);
       for (int i = 0; i < colorsSize; i++) {
         SkColor color = JsiSkColor::fromValue(
@@ -295,6 +313,12 @@ public:
     if (count >= 3 && !arguments[2].isNull() && !arguments[2].isUndefined()) {
       auto jsiTexs = arguments[2].asObject(runtime).asArray(runtime);
       auto texsSize = jsiTexs.size(runtime);
+      
+      // Validate textures array - must be exactly 4 points
+      if (texsSize != 4) {
+        throw std::invalid_argument("Texture coordinates array must contain exactly 4 points");
+      }
+      
       texs.reserve(texsSize);
       for (int i = 0; i < texsSize; i++) {
         auto point = JsiSkPoint::fromValue(
@@ -306,7 +330,8 @@ public:
     auto paint =
         count >= 4 ? JsiSkPaint::fromValue(runtime, arguments[4]) : nullptr;
     auto blendMode = static_cast<SkBlendMode>(arguments[3].asNumber());
-    _canvas->drawPatch(cubics.data(), colors.data(), texs.data(), blendMode,
+    _canvas->drawPatch(cubics.data(), colors.empty() ? nullptr : colors.data(), 
+                       texs.empty() ? nullptr : texs.data(), blendMode,
                        *paint);
     return jsi::Value::undefined();
   }
@@ -364,6 +389,12 @@ public:
 
     std::vector<SkGlyphID> glyphs;
     int glyphsSize = static_cast<int>(jsiGlyphs.size(runtime));
+    
+    // Validate that glyphs and positions arrays have the same size
+    if (glyphsSize != pointsSize) {
+      throw std::invalid_argument("Glyphs and positions arrays must have the same length");
+    }
+    
     glyphs.reserve(glyphsSize);
     for (int i = 0; i < glyphsSize; i++) {
       glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
@@ -522,11 +553,22 @@ public:
           runtime, rects.getValueAtIndex(runtime, i).asObject(runtime));
       skRects.push_back(*rect.get());
     }
+    
+    // Validate transforms and rects have the same size
+    if (xformsSize != rectsSize) {
+      throw std::invalid_argument("Transforms and rects arrays must have the same length");
+    }
 
     std::vector<SkColor> colors;
     if (count > 5 && !arguments[5].isUndefined()) {
       auto colorsArray = arguments[5].asObject(runtime).asArray(runtime);
       int colorsSize = static_cast<int>(colorsArray.size(runtime));
+      
+      // Validate colors array matches the size of sprites and transforms
+      if (colorsSize != rectsSize) {
+        throw std::invalid_argument("Colors array must have the same length as rects/transforms");
+      }
+      
       colors.reserve(colorsSize);
       for (int i = 0; i < colorsSize; i++) {
         // Convert from [r,g,b,a] in [0,1] to SkColor
@@ -551,7 +593,8 @@ public:
       sampling = SamplingOptionsFromValue(runtime, arguments[6]);
     }
     _canvas->drawAtlas(atlas.get(), xforms.data(), skRects.data(),
-                       colors.data(), skRects.size(), blendMode, sampling,
+                       colors.empty() ? nullptr : colors.data(), 
+                       skRects.size(), blendMode, sampling,
                        nullptr, paint.get());
 
     return jsi::Value::undefined();

package/cpp/api/recorder/Drawings.h

@@ -418,7 +418,7 @@ public:
         SkPaint shadowPaint;
         shadowPaint.setAntiAlias(true);
         shadowPaint.setColor(shadow.color.value_or(SK_ColorBLACK));
-        shadowPaint.setAlphaf(opacity);
+        shadowPaint.setAlphaf(opacity * shadowPaint.getAlphaf());
         shadowPaint.setMaskFilter(SkMaskFilter::MakeBlur(
             SkBlurStyle::kNormal_SkBlurStyle, shadow.blur, true));
 
@@ -442,7 +442,7 @@ public:
         SkPaint shadowPaint;
         shadowPaint.setAntiAlias(true);
         shadowPaint.setColor(shadow.color.value_or(SK_ColorBLACK));
-        shadowPaint.setAlphaf(opacity);
+        shadowPaint.setAlphaf(opacity * shadowPaint.getAlphaf());
         shadowPaint.setMaskFilter(SkMaskFilter::MakeBlur(
             SkBlurStyle::kNormal_SkBlurStyle, shadow.blur, true));
 
@@ -637,6 +637,16 @@ public:
   }
 
   void draw(DrawingCtx *ctx) {
+    // Validate colors array has exactly 4 colors if provided
+    if (props.colors.has_value() && props.colors.value().size() != 4) {
+      throw std::invalid_argument("Colors array for patch must have exactly 4 colors");
+    }
+    
+    // Validate texture array has exactly 4 points if provided
+    if (props.texture.has_value() && props.texture.value().size() != 4) {
+      throw std::invalid_argument("Texture coordinates array for patch must have exactly 4 points");
+    }
+
     // Determine default blend mode based on presence of colors
     SkBlendMode defaultBlendMode = props.colors.has_value()
                                        ? SkBlendMode::kDstOver
@@ -676,6 +686,15 @@ public:
   }
 
   void draw(DrawingCtx *ctx) {
+    // Validate array sizes
+    if (props.colors.has_value() && props.colors.value().size() != props.vertices.size()) {
+      throw std::invalid_argument("Colors array must have the same size as vertices array");
+    }
+    
+    if (props.textures.has_value() && props.textures.value().size() != props.vertices.size()) {
+      throw std::invalid_argument("Textures array must have the same size as vertices array");
+    }
+
     // Create vertices using MakeCopy
     auto vertices = SkVertices::MakeCopy(
         props.mode, static_cast<int>(props.vertices.size()),
@@ -909,6 +928,16 @@ public:
 
   void draw(DrawingCtx *ctx) {
     if (props.image) {
+      // Validate transforms and sprites have the same size
+      if (props.transforms.size() != props.sprites.size()) {
+        throw std::invalid_argument("transforms and sprites arrays must have the same length");
+      }
+      
+      // Validate colors array matches if provided
+      if (props.colors.has_value() && props.colors.value().size() != props.transforms.size()) {
+        throw std::invalid_argument("colors array must have the same length as transforms/sprites");
+      }
+      
       auto colors =
           props.colors.has_value() ? props.colors.value().data() : nullptr;
       auto blendMode = props.blendMode.value_or(SkBlendMode::kDstOver);

package/cpp/api/recorder/Shaders.h

@@ -239,6 +239,16 @@ public:
   }
 
   void pushShader(DrawingCtx *ctx) {
+    // Validate colors array has at least 2 colors
+    if (props.colors.size() < 2) {
+      throw std::invalid_argument("Colors array must have at least 2 colors");
+    }
+    
+    // Validate positions array matches colors array in size
+    if (props.positions.has_value() && props.positions.value().size() != props.colors.size()) {
+      throw std::invalid_argument("Positions array must have the same size as colors array");
+    }
+    
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
     const SkPoint pts[2] = {props.start, props.end};
     auto shader = SkGradientShader::MakeLinear(
@@ -276,6 +286,16 @@ public:
   }
 
   void pushShader(DrawingCtx *ctx) {
+    // Validate colors array has at least 2 colors
+    if (props.colors.size() < 2) {
+      throw std::invalid_argument("Colors array must have at least 2 colors");
+    }
+    
+    // Validate positions array matches colors array in size
+    if (props.positions.has_value() && props.positions.value().size() != props.colors.size()) {
+      throw std::invalid_argument("Positions array must have the same size as colors array");
+    }
+    
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
     auto shader = SkGradientShader::MakeRadial(
         props.center, props.radius, props.colors.data(),
@@ -314,6 +334,16 @@ public:
   }
 
   void pushShader(DrawingCtx *ctx) {
+    // Validate colors array has at least 2 colors
+    if (props.colors.size() < 2) {
+      throw std::invalid_argument("Colors array must have at least 2 colors");
+    }
+    
+    // Validate positions array matches colors array in size
+    if (props.positions.has_value() && props.positions.value().size() != props.colors.size()) {
+      throw std::invalid_argument("Positions array must have the same size as colors array");
+    }
+    
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
     auto shader = SkGradientShader::MakeSweep(
         props.center.x(), props.center.y(), props.colors.data(),
@@ -355,6 +385,16 @@ public:
   }
 
   void pushShader(DrawingCtx *ctx) {
+    // Validate colors array has at least 2 colors
+    if (props.colors.size() < 2) {
+      throw std::invalid_argument("Colors array must have at least 2 colors");
+    }
+    
+    // Validate positions array matches colors array in size
+    if (props.positions.has_value() && props.positions.value().size() != props.colors.size()) {
+      throw std::invalid_argument("Positions array must have the same size as colors array");
+    }
+    
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
     auto shader = SkGradientShader::MakeTwoPointConical(
         props.start, props.startRadius, props.end, props.endRadius,

package/cpp/skia/include/codec/SkCodec.h

@@ -784,12 +784,46 @@ public:
      *
      *  As such, future decoding calls may require a rewind.
      *
-     *  For still (non-animated) image codecs, this will return 0.
+     *  `getRepetitionCount` will return `0` in two cases:
+     *  1. Still (non-animated) images.
+     *  2. Animated images that only play the animation once (i.e. that don't
+     *     repeat the animation)
+     *  `isAnimated` can be used to disambiguate between these two cases.
      */
     int getRepetitionCount() {
         return this->onGetRepetitionCount();
     }
 
+    /**
+     * `isAnimated` returns whether the full input is expected to contain an
+     * animated image (i.e. more than 1 image frame).  This can be used to
+     * disambiguate the meaning of `getRepetitionCount` returning `0` (see
+     * `getRepetitionCount`'s doc comment for more details).
+     *
+     * Note that in some codecs `getFrameCount()` only returns the number of
+     * frames for which all the metadata has been already successfully decoded.
+     * Therefore for a partial input `isAnimated()` may return "yes", even
+     * though `getFrameCount()` may temporarily return `1` until more of the
+     * input is available.
+     *
+     * When handling partial input, some codecs may not know until later (e.g.
+     * until encountering additional image frames) whether the given image has
+     * more than one frame.  Such codecs may initially return
+     * `IsAnimated::kUnknown` and only later give a definitive "yes" or "no"
+     * answer.  GIF format is one example where this may happen.
+     *
+     * Other codecs may be able to decode the information from the metadata
+     * present before the first image frame.  Such codecs should be able to give
+     * a definitive "yes" or "no" answer as soon as they are constructed.  PNG
+     * format is one example where this happens.
+     */
+    enum class IsAnimated {
+        kYes,
+        kNo,
+        kUnknown,
+    };
+    IsAnimated isAnimated() { return this->onIsAnimated(); }
+
     // Register a decoder at runtime by passing two function pointers:
     //    - peek() to return true if the span of bytes appears to be your encoded format;
     //    - make() to attempt to create an SkCodec from the given stream.
@@ -937,6 +971,10 @@ protected:
         return 0;
     }
 
+    virtual IsAnimated onIsAnimated() {
+        return IsAnimated::kNo;
+    }
+
 private:
     const SkEncodedInfo                fEncodedInfo;
     XformFormat                        fSrcXformFormat;

package/cpp/skia/include/config/SkUserConfig.h

@@ -80,16 +80,6 @@
 */
 //#define SK_CANVAS_SAVE_RESTORE_PREALLOC_COUNT 32
 
-/* Determines whether to build code that supports the Ganesh GPU backend. Some classes
-   that are not GPU-specific, such as SkShader subclasses, have optional code
-   that is used allows them to interact with this GPU backend. If you'd like to
-   include this code, include -DSK_GANESH in your cflags or uncomment below.
-   Defaults to not set (No Ganesh GPU backend).
-   This define affects the ABI of Skia, so make sure it matches the client which uses
-   the compiled version of Skia.
-*/
-//#define SK_GANESH
-
 /* Skia makes use of histogram logging macros to trace the frequency of
    events. By default, Skia provides no-op versions of these macros.
    Skia consumers can provide their own definitions of these macros to
@@ -99,6 +89,7 @@
 //#define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
 //#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
+//#define SK_HISTOGRAM_CUSTOM_COUNTS(name, sample, countMin, countMax, bucketCount)
 //#define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 
 /*

package/cpp/skia/include/core/SkCanvas.h

@@ -54,6 +54,7 @@ class GrRecordingContext;
 
 class SkBitmap;
 class SkBlender;
+class SkBlurMaskFilterImpl;
 class SkColorSpace;
 class SkData;
 class SkDevice;
@@ -2679,11 +2680,14 @@ private:
     // into the canvas' global space.
     SkRect computeDeviceClipBounds(bool outsetForAA=true) const;
 
-    // Attempt to draw a rrect with an analytic blur. If the paint does not contain a blur, or the
-    // geometry can't be drawn with an analytic blur by the device, a layer is returned for a
-    // regular draw. If the draw succeeds or predrawNotify fails, nullopt is returned indicating
-    // that nothing further should be drawn.
+    // Returns the paint's mask filter if it can be used to draw an rrect with an analytic blur, and
+    // returns null otherwise.
+    const SkBlurMaskFilterImpl* canAttemptBlurredRRectDraw(const SkPaint&) const;
+
+    // Attempt to draw a rrect with an analytic blur. If the draw succeeds or predrawNotify fails,
+    // nullopt is returned indicating that nothing further should be drawn.
     std::optional<AutoLayerForImageFilter> attemptBlurredRRectDraw(const SkRRect&,
+                                                                   const SkBlurMaskFilterImpl*,
                                                                    const SkPaint&,
                                                                    SkEnumBitMask<PredrawFlags>);
 

package/cpp/skia/include/core/SkContourMeasure.h

@@ -91,13 +91,13 @@ public:
             return *this;
         }
 
-        bool operator==(const ForwardVerbIterator& other) {
+        bool operator==(const ForwardVerbIterator& other) const {
             SkASSERT(fSegments.data() != other.fSegments.data() ||
                      fSegments.size() == other.fSegments.size());
             return fSegments.data() == other.fSegments.data();
         }
 
-        bool operator!=(const ForwardVerbIterator& other) {
+        bool operator!=(const ForwardVerbIterator& other) const {
             return !((*this) == other);
         }
 

package/cpp/skia/include/core/SkMilestone.h

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 134
+#define SK_MILESTONE 136
 #endif

package/cpp/skia/include/core/SkPaint.h

@@ -317,15 +317,18 @@ public:
     */
     SkScalar getStrokeMiter() const { return fMiterLimit; }
 
-    /** Sets the limit at which a sharp corner is drawn beveled.
-        Valid values are zero and greater.
-        Has no effect if miter is less than zero.
+    /** When stroking a small joinAngle with miter, the miterLength may be very long.
+        When miterLength > maxMiterLength (or joinAngle < minJoinAngle) the join will become bevel.
+        miterLimit = maxMiterLength / strokeWidth or miterLimit = 1 / sin(minJoinAngle / 2).
 
-        @param miter  zero and greater miter limit
+        This call has no effect if the miterLimit passed is less than zero.
+        Values less than one will be treated as bevel.
+
+        @param miterLimit  zero and greater miter limit
 
         example: https://fiddle.skia.org/c/@Paint_setStrokeMiter
     */
-    void setStrokeMiter(SkScalar miter);
+    void setStrokeMiter(SkScalar miterLimit);
 
     /** \enum SkPaint::Cap
         Cap draws at the beginning and end of an open path contour.

package/cpp/skia/include/core/SkStream.h

@@ -79,10 +79,12 @@ public:
     [[nodiscard]] bool readS8(int8_t*);
     [[nodiscard]] bool readS16(int16_t*);
     [[nodiscard]] bool readS32(int32_t*);
+    [[nodiscard]] bool readS64(int64_t*);
 
-    [[nodiscard]] bool readU8(uint8_t* i) { return this->readS8((int8_t*)i); }
+    [[nodiscard]] bool readU8(uint8_t* i)   { return this->readS8((int8_t*)i); }
     [[nodiscard]] bool readU16(uint16_t* i) { return this->readS16((int16_t*)i); }
     [[nodiscard]] bool readU32(uint32_t* i) { return this->readS32((int32_t*)i); }
+    [[nodiscard]] bool readU64(uint64_t* i) { return this->readS64((int64_t*)i); }
 
     [[nodiscard]] bool readBool(bool* b) {
         uint8_t i;
@@ -240,8 +242,11 @@ public:
         uint16_t v = SkToU16(value);
         return this->write(&v, 2);
     }
-    bool write32(uint32_t v) {
-        return this->write(&v, 4);
+    bool write32(uint32_t value) {
+        return this->write(&value, 4);
+    }
+    bool write64(uint64_t value) {
+        return this->write(&value, 8);
     }
 
     bool writeText(const char text[]) {

package/cpp/skia/include/core/SkTextBlob.h

@@ -209,13 +209,13 @@ public:
     class SK_API Iter {
     public:
         struct Run {
-            SkTypeface*     fTypeface;
-            int             fGlyphCount;
-            const uint16_t* fGlyphIndices;
+            SkTypeface* fTypeface;
+            int fGlyphCount;
+            const SkGlyphID* fGlyphIndices;
 #ifdef SK_UNTIL_CRBUG_1187654_IS_FIXED
             const uint32_t* fClusterIndex_forTest;
-            int             fUtf8Size_forTest;
-            const char*     fUtf8_forTest;
+            int fUtf8Size_forTest;
+            const char* fUtf8_forTest;
 #endif
         };
 
@@ -229,10 +229,10 @@ public:
 
         // Experimental, DO NO USE, will change/go-away
         struct ExperimentalRun {
-            SkFont          font;
-            int             count;
-            const uint16_t* glyphs;
-            const SkPoint*  positions;
+            SkFont font;
+            int count;
+            const SkGlyphID* glyphs;
+            const SkPoint* positions;
         };
         bool experimentalNext(ExperimentalRun*);
 

package/cpp/skia/include/core/SkTypeface.h

@@ -366,12 +366,10 @@ protected:
     virtual bool onGetFixedPitch() const; // TODO: = 0;
 
     // Must return a valid scaler context. It can not return nullptr.
-    virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
-                                                                   const SkDescriptor*) const = 0;
+    virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(
+        const SkScalerContextEffects&, const SkDescriptor*) const = 0;
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContextAsProxyTypeface
-                                                                  (const SkScalerContextEffects&,
-                                                                   const SkDescriptor*,
-                                                                   sk_sp<SkTypeface>) const;
+        (const SkScalerContextEffects&, const SkDescriptor*, SkTypeface* proxyTypeface) const;
     virtual void onFilterRec(SkScalerContextRec*) const = 0;
     friend class SkScalerContext;  // onFilterRec
 
@@ -442,8 +440,8 @@ private:
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
     friend class SkTypeface_proxy;
-
     friend class SkFontPriv;         // getGlyphToUnicodeMap
+    friend void TestSkTypefaceGlyphToUnicodeMap(SkTypeface&, SkUnichar*);
 
 private:
     SkTypefaceID        fUniqueID;

package/cpp/skia/include/core/SkTypes.h

@@ -97,6 +97,7 @@
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
     defined(SK_HISTOGRAM_MEMORY_KB)    || \
+    defined(SK_HISTOGRAM_CUSTOM_COUNTS)|| \
     defined(SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES)
 #  define SK_HISTOGRAMS_ENABLED 1
 #else
@@ -119,6 +120,10 @@
 #  define SK_HISTOGRAM_MEMORY_KB(name, sample)
 #endif
 
+#ifndef SK_HISTOGRAM_CUSTOM_COUNTS
+#  define SK_HISTOGRAM_CUSTOM_COUNTS(name, sample, countMin, countMax, bucketCount)
+#endif
+
 #ifndef SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES
 #  define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 #endif

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -16,9 +16,12 @@
 #include <vector>
 
 class SkCanvas;
+class SkCodec;
+class SkData;
 class SkExecutor;
 class SkPDFArray;
 class SkPDFStructTree;
+class SkPixmap;
 class SkWStream;
 
 #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
@@ -80,6 +83,9 @@ struct DateTime {
     void toISO8601(SkString* dst) const;
 };
 
+using DecodeJpegCallback = std::unique_ptr<SkCodec> (*)(sk_sp<SkData>);
+using EncodeJpegCallback = bool (*)(SkWStream* dst, const SkPixmap& src, int quality);
+
 /** Optional metadata to be passed into the PDF factory function.
 */
 struct Metadata {
@@ -157,6 +163,7 @@ struct Metadata {
     enum class Outline : int {
         None = 0,
         StructureElementHeaders = 1,
+        StructureElements = 2,
     } fOutline = Outline::None;
 
     /** Executor to handle threaded work within PDF Backend. If this is nullptr,
@@ -186,14 +193,50 @@ struct Metadata {
     enum Subsetter {
         kHarfbuzz_Subsetter,
     } fSubsetter = kHarfbuzz_Subsetter;
+
+    /** Clients can provide a way to decode jpeg. To use Skia's JPEG decoder, pass in
+        SkJpegDecoder::Decode. If not supplied, all images will need to be re-encoded
+        as jpegs or deflated images before embedding. If supplied, Skia may be able to
+        skip the re-encoding step.
+        Skia's JPEG decoder can be used here.
+    */
+    SkPDF::DecodeJpegCallback jpegDecoder = nullptr;
+
+    /** Clients can provide a way to encode jpeg. If not supplied, images will be embedded
+        as a deflated image, potentially making them much larger. If clients provide
+        their own implementation, JPEGs should be encoded to RGB (not YUV) otherwise they
+        will have the wrong surrounding metadata provided by Skia.
+        Skia's JPEG encoder can be used here.
+    */
+    SkPDF::EncodeJpegCallback jpegEncoder = nullptr;
+
+    // Skia's PDF support depends on having both a jpeg encoder and decoder for writing
+    // compact PDFs. It will technically work, but produce larger than optimal PDFs
+    // if either the decoder or encoder are left as nullptr. If clients will be creating
+    // PDFs that don't use images or otherwise want to incur this cost (with the upside
+    // of not having a jpeg library), they should set this to true to avoid an internal
+    // assert from firing.
+    bool allowNoJpegs = false;
 };
 
+namespace NodeID {
+static const constexpr int Nothing = 0;
+static const constexpr int OtherArtifact = -1;
+static const constexpr int PaginationArtifact = -2;
+static const constexpr int PaginationHeaderArtifact = -3;
+static const constexpr int PaginationFooterArtifact = -4;
+static const constexpr int PaginationWatermarkArtifact = -5;
+static const constexpr int LayoutArtifact = -6;
+static const constexpr int PageArtifact = -7;
+static const constexpr int BackgroundArtifact = -8;
+}  // namespace NodeID
+
 /** Associate a node ID with subsequent drawing commands in an
     SkCanvas.  The same node ID can appear in a StructureElementNode
     in order to associate a document's structure element tree with
     its content.
 
-    A node ID of zero indicates no node ID.
+    A node ID of zero indicates no node ID. Negative node IDs are reserved.
 
     @param canvas  The canvas used to draw to the PDF.
     @param nodeId  The node ID for subsequent drawing commands.
@@ -207,15 +250,17 @@ SK_API void SetNodeId(SkCanvas* dst, int nodeID);
     @param stream A PDF document will be written to this stream.  The document may write
            to the stream at anytime during its lifetime, until either close() is
            called or the document is deleted.
-    @param metadata a PDFmetadata object.  Any fields may be left empty.
+    @param metadata a PDFmetadata object. Some fields may be left empty.
 
     @returns NULL if there is an error, otherwise a newly created PDF-backed SkDocument.
 */
 SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream, const Metadata& metadata);
 
+#if !defined(SK_DISABLE_LEGACY_PDF_JPEG)
 static inline sk_sp<SkDocument> MakeDocument(SkWStream* stream) {
     return MakeDocument(stream, Metadata());
 }
+#endif
 
 }  // namespace SkPDF