@shopify/react-native-skia 1.5.3 → 1.5.5

package/cpp/rnskia/DawnWindowContext.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "DawnUtils.h"
+#include "WindowContext.h"
+
+#include "dawn/native/MetalBackend.h"
+#include "webgpu/webgpu_cpp.h"
+
+#include "include/core/SkColorSpace.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/Context.h"
+#include "include/gpu/graphite/ContextOptions.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/Surface.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+#include "include/gpu/graphite/dawn/DawnUtils.h"
+
+namespace RNSkia {
+
+class DawnWindowContext : public WindowContext {
+public:
+  DawnWindowContext(skgpu::graphite::Recorder *recorder, wgpu::Device device,
+                    wgpu::Surface surface, int width, int height)
+      : _recorder(recorder), _device(device), _surface(surface), _width(width),
+        _height(height) {
+    wgpu::SurfaceConfiguration config;
+    config.device = _device;
+    config.format = DawnUtils::PreferredTextureFormat;
+    config.width = _width;
+    config.height = _height;
+#ifdef __APPLE__
+    config.alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
+#endif
+    _surface.Configure(&config);
+  }
+
+  sk_sp<SkSurface> getSurface() override {
+    wgpu::SurfaceTexture surfaceTexture;
+    _surface.GetCurrentTexture(&surfaceTexture);
+    auto texture = surfaceTexture.texture;
+    skgpu::graphite::DawnTextureInfo info(
+        /*sampleCount=*/1, skgpu::Mipmapped::kNo,
+        DawnUtils::PreferredTextureFormat, texture.GetUsage(),
+        wgpu::TextureAspect::All);
+    auto backendTex = skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
+    sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeSRGB();
+    SkSurfaceProps surfaceProps;
+    auto surface = SkSurfaces::WrapBackendTexture(_recorder, backendTex,
+                                                  DawnUtils::PreferedColorType,
+                                                  colorSpace, &surfaceProps);
+    return surface;
+  }
+
+  void present() override;
+
+  void resize(int width, int height) override {
+    throw std::runtime_error("resize not implemented yet");
+  }
+
+  int getWidth() override { return _width; }
+
+  int getHeight() override { return _height; }
+
+private:
+  skgpu::graphite::Recorder *_recorder;
+  // TODO: keep device in DawnContext? Do we need it for resizing?
+  wgpu::Device _device;
+  wgpu::Surface _surface;
+  int _width;
+  int _height;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/ImageProvider.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+
+#include "include/core/SkTiledImageUtils.h"
+#include "include/gpu/graphite/Image.h"
+#include "include/gpu/graphite/ImageProvider.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "src/core/SkLRUCache.h"
+
+namespace RNSkia {
+
+// Currently, we give each new Recorder its own ImageProvider. This means we
+// don't have to deal w/ any threading issues.
+// TODO: We should probably have this class generate and report some cache stats
+// TODO: Hook up to listener system?
+// TODO: add testing of a single ImageProvider passed to multiple recorders
+class ImageProvider : public skgpu::graphite::ImageProvider {
+public:
+  ImageProvider() : fCache(kDefaultNumCachedImages) {}
+  ~ImageProvider() override {}
+
+  static sk_sp<ImageProvider> Make() { return sk_ref_sp(new ImageProvider); }
+
+  sk_sp<SkImage>
+  findOrCreate(skgpu::graphite::Recorder *recorder, const SkImage *image,
+               SkImage::RequiredProperties requiredProps) override {
+    if (!requiredProps.fMipmapped) {
+      // If no mipmaps are required, check to see if we have a mipmapped version
+      // anyway - since it can be used in that case.
+      // TODO: we could get fancy and, if ever a mipmapped key eclipsed a
+      // non-mipmapped key, we could remove the hidden non-mipmapped key/image
+      // from the cache.
+      ImageKey mipMappedKey(image, /* mipmapped= */ true);
+      auto result = fCache.find(mipMappedKey);
+      if (result) {
+        return *result;
+      }
+    }
+
+    ImageKey key(image, requiredProps.fMipmapped);
+
+    auto result = fCache.find(key);
+    if (result) {
+      return *result;
+    }
+
+    sk_sp<SkImage> newImage =
+        SkImages::TextureFromImage(recorder, image, requiredProps);
+    if (!newImage) {
+      return nullptr;
+    }
+
+    result = fCache.insert(key, std::move(newImage));
+    SkASSERT(result);
+
+    return *result;
+  }
+
+private:
+  static constexpr int kDefaultNumCachedImages = 256;
+
+  class ImageKey {
+  public:
+    ImageKey(const SkImage *image, bool mipmapped) {
+      uint32_t flags = mipmapped ? 0x1 : 0x0;
+      SkTiledImageUtils::GetImageKeyValues(image, &fValues[1]);
+      fValues[kNumValues - 1] = flags;
+      fValues[0] =
+          SkChecksum::Hash32(&fValues[1], (kNumValues - 1) * sizeof(uint32_t));
+    }
+
+    uint32_t hash() const { return fValues[0]; }
+
+    bool operator==(const ImageKey &other) const {
+      for (int i = 0; i < kNumValues; ++i) {
+        if (fValues[i] != other.fValues[i]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+    bool operator!=(const ImageKey &other) const { return !(*this == other); }
+
+  private:
+    static const int kNumValues = SkTiledImageUtils::kNumImageKeyValues + 2;
+
+    uint32_t fValues[kNumValues];
+  };
+
+  struct ImageHash {
+    size_t operator()(const ImageKey &key) const { return key.hash(); }
+  };
+
+  SkLRUCache<ImageKey, sk_sp<SkImage>, ImageHash> fCache;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -108,7 +108,13 @@ public:
     } else {
       image = _surface->makeImageSnapshot();
     }
+#if defined(SK_GRAPHITE)
+    DawnContext::getInstance().submitRecording(
+        _surface->recorder()->snap().get());
+    return DawnContext::getInstance().MakeRasterImage(image);
+#else
     return image->makeNonTextureImage();
+#endif
   }
 
   /**

package/cpp/skia/include/android/SkAnimatedImage.h

@@ -110,6 +110,19 @@ public:
      */
     int getFrameCount() const { return fFrameCount; }
 
+    /**
+     *  Change the filter mode.
+     *
+     *  By default, the image will apply bilinear filtering when drawing in the
+     *  OnDraw method.
+     */
+    void setFilterMode(SkFilterMode filterMode);
+
+    /**
+     *  Return the filter mode used for sampling when drawing.
+     */
+    SkFilterMode getFilterMode() const { return fFilterMode; }
+
 protected:
     SkRect onGetBounds() override;
     void onDraw(SkCanvas*) override;
@@ -152,6 +165,7 @@ private:
     Frame                           fRestoreFrame;
     int                             fRepetitionCount;
     int                             fRepetitionsCompleted;
+    SkFilterMode                    fFilterMode = SkFilterMode::kLinear;
 
     SkAnimatedImage(std::unique_ptr<SkAndroidCodec>, const SkImageInfo& requestedInfo,
             SkIRect cropRect, sk_sp<SkPicture> postProcess);

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

@@ -18,13 +18,15 @@ class SkStream;
 
 namespace SkAvifDecoder {
 
-/** Returns true if this data claims to be a AVIF image. */
+namespace LibAvif {
+
+/** Returns true if this data claims to be an AVIF image. */
 SK_API bool IsAvif(const void*, size_t);
 
 /**
- *  Attempts to decode the given bytes as a AVIF.
+ *  Attempts to decode the given bytes as an AVIF.
  *
- *  If the bytes are not a AVIF, returns nullptr.
+ *  If the bytes are not an AVIF, returns nullptr.
  *
  *  DecodeContext is ignored
  */
@@ -39,6 +41,40 @@ inline constexpr SkCodecs::Decoder Decoder() {
     return { "avif", IsAvif, Decode };
 }
 
+}  // namespace LibAvif
+
+// This function is in the root SkAvifDecoder namespace. It simply routes
+// everything through the LibAvif namespace and exists for backwards
+// compatibility.
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "avif", LibAvif::IsAvif, LibAvif::Decode };
+}
+
+namespace CrabbyAvif {
+
+/** Returns true if this data claims to be an AVIF image. */
+SK_API bool IsAvif(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as an AVIF.
+ *
+ *  If the bytes are not an AVIF, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "avif", IsAvif, Decode };
+}
+
+}  // namespace CrabbyAvif
+
 }  // namespace SkAvifDecoder
 
 #endif  // SkAvifDecoder_DEFINED

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

@@ -239,6 +239,16 @@ public:
         return this->getEncodedInfo().profile();
     }
 
+    /**
+     * Whether the encoded input uses 16 or more bits per component.
+     */
+    bool hasHighBitDepthEncodedData() const {
+        // API design note: We don't return `bitsPerComponent` because it may be
+        // misleading in some cases - see https://crbug.com/359350061#comment4
+        // for more details.
+        return this->getEncodedInfo().bitsPerComponent() >= 16;
+    }
+
     /**
      *  Returns the image orientation stored in the EXIF data.
      *  If there is no EXIF data, or if we cannot read the EXIF data, returns kTopLeft.
@@ -637,6 +647,12 @@ public:
      *  Return the number of frames in the image.
      *
      *  May require reading through the stream.
+     *
+     *  Note that some codecs may be unable to gather `FrameInfo` for all frames
+     *  in case of `kIncompleteInput`.  For such codecs `getFrameCount` may
+     *  initially report a low frame count.  After the underlying `SkStream`
+     *  provides additional data, then calling `getFrameCount` again may return
+     *  an updated, increased frame count.
      */
     int getFrameCount() {
         return this->onGetFrameCount();

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

@@ -90,9 +90,10 @@
    integrate with their histogram collection backend.
 */
 //#define SK_HISTOGRAM_BOOLEAN(name, sample)
-//#define SK_HISTOGRAM_ENUMERATION(name, sample, enum_size)
-//#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
+//#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_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 
 // To use smaller but slower mipmap builder
 //#define SK_USE_DRAWING_MIPMAP_DOWNSAMPLER

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

@@ -28,6 +28,7 @@
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTileMode.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkDeque.h"
@@ -700,7 +701,8 @@ public:
             @return                SaveLayerRec with empty fBackdrop
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
-            : SaveLayerRec(bounds, paint, nullptr, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, nullptr, nullptr, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
 
         /** Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
 
@@ -716,9 +718,10 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, backdrop, nullptr, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
 
-        /** Sets fBounds, fColorSpace, and fSaveLayerFlags.
+        /** Sets fBounds, fBackdrop, fColorSpace, and fSaveLayerFlags.
 
             @param bounds          layer dimensions; may be nullptr
             @param paint           applied to layer when overlaying prior layer;
@@ -738,15 +741,44 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      const SkColorSpace* colorSpace, SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
+
+
+        /** Sets fBounds, fBackdrop, fBackdropTileMode, fColorSpace, and fSaveLayerFlags.
+
+            @param bounds           layer dimensions; may be nullptr
+            @param paint            applied to layer when overlaying prior layer;
+                                    may be nullptr
+            @param backdrop         If not null, this causes the current layer to be filtered by
+                                    backdrop, and then drawn into the new layer
+                                    (respecting the current clip).
+                                    If null, the new layer is initialized with transparent-black.
+            @param backdropTileMode If the 'backdrop' is not null, or 'saveLayerFlags' has
+                                    kInitWithPrevious set, this tile mode is used when the new layer
+                                    would read outside the backdrop image's available content.
+            @param colorSpace       If not null, when the layer is restored, a color space
+                                    conversion will be applied from this color space to the parent's
+                                    color space. The restore paint and backdrop filters will be
+                                    applied in this color space.
+                                    If null, the new layer will inherit the color space from its
+                                    parent.
+            @param saveLayerFlags   SaveLayerRec options to modify layer
+            @return                 SaveLayerRec fully specified
+        */
+        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
+                     SkTileMode backdropTileMode, const SkColorSpace* colorSpace,
+                     SaveLayerFlags saveLayerFlags)
+            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, backdropTileMode,
+                           saveLayerFlags, /*filters=*/{}) {}
 
         /** hints at layer size limit */
-        const SkRect*        fBounds         = nullptr;
+        const SkRect* fBounds = nullptr;
 
         /** modifies overlay */
-        const SkPaint*       fPaint          = nullptr;
+        const SkPaint* fPaint = nullptr;
 
-        FilterSpan           fFilters        = {};
+        FilterSpan fFilters = {};
 
         /**
          *  If not null, this triggers the same initialization behavior as setting
@@ -754,17 +786,24 @@ public:
          *  the new layer, rather than initializing the new layer with transparent-black.
          *  This is then filtered by fBackdrop (respecting the current clip).
          */
-        const SkImageFilter* fBackdrop       = nullptr;
+        const SkImageFilter* fBackdrop = nullptr;
+
+        /**
+         * If the layer is initialized with prior content (and/or with a backdrop filter) and this
+         * would require sampling outside of the available backdrop, this is the tilemode applied
+         * to the boundary of the prior layer's image.
+         */
+        SkTileMode fBackdropTileMode = SkTileMode::kClamp;
 
         /**
          * If not null, this triggers a color space conversion when the layer is restored. It
          * will be as if the layer's contents are drawn in this color space. Filters from
          * fBackdrop and fPaint will be applied in this color space.
          */
-        const SkColorSpace* fColorSpace      = nullptr;
+        const SkColorSpace* fColorSpace = nullptr;
 
         /** preserves LCD text, creates with prior layer contents */
-        SaveLayerFlags       fSaveLayerFlags = 0;
+        SaveLayerFlags fSaveLayerFlags = 0;
 
     private:
         friend class SkCanvas;
@@ -775,12 +814,14 @@ public:
                      const SkImageFilter* backdrop,
                      const SkColorSpace* colorSpace,
                      SkScalar backdropScale,
+                     SkTileMode backdropTileMode,
                      SaveLayerFlags saveLayerFlags,
                      FilterSpan filters)
                 : fBounds(bounds)
                 , fPaint(paint)
                 , fFilters(filters)
                 , fBackdrop(backdrop)
+                , fBackdropTileMode(backdropTileMode)
                 , fColorSpace(colorSpace)
                 , fSaveLayerFlags(saveLayerFlags)
                 , fExperimentalBackdropScale(backdropScale) {
@@ -2591,12 +2632,16 @@ private:
      * before any filtering, or as part of the copy, and is then drawn with 1/scaleFactor to 'dst'.
      * Must be 1.0 if 'compat' is kYes (i.e. any scale factor has already been baked into the
      * relative transforms between the devices).
+     *
+     * 'srcTileMode' is the tile mode to apply to the boundary of the 'src' image when insufficient
+     * content is available. It defaults to kDecal for the regular saveLayer() case.
      */
     void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
                                       FilterSpan filters, const SkPaint& paint,
                                       DeviceCompatibleWithFilter compat,
                                       const SkColorInfo& filterColorInfo,
                                       SkScalar scaleFactor = 1.f,
+                                      SkTileMode srcTileMode = SkTileMode::kDecal,
                                       bool srcIsCoverageLayer = false);
 
     /*

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

@@ -11,13 +11,17 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAssert.h"
 #include "include/private/base/SkTDArray.h"
 
+#include <cstddef>
 #include <memory>
 
 class SkMatrix;
 class SkPath;
+enum class SkPathVerb;
 
 class SK_API SkContourMeasure : public SkRefCnt {
 public:
@@ -57,6 +61,78 @@ public:
      */
     bool isClosed() const { return fIsClosed; }
 
+    /** Measurement data for individual verbs.
+     */
+    struct VerbMeasure {
+        SkScalar              fDistance; // Cumulative distance along the current contour.
+        SkPathVerb            fVerb;     // Verb type.
+        SkSpan<const SkPoint> fPts;      // Verb points.
+    };
+
+private:
+    struct Segment;
+
+public:
+    /** Utility for iterating over the current contour verbs:
+     *
+     *   for (const auto verb_measure : contour_measure) {
+     *     ...
+     *   }
+     */
+    class ForwardVerbIterator final {
+    public:
+        VerbMeasure operator*() const;
+
+        ForwardVerbIterator& operator++() {
+            SkASSERT(!fSegments.empty());
+
+            fSegments = LastSegForCurrentVerb(fSegments.subspan(1));
+
+            return *this;
+        }
+
+        bool operator==(const ForwardVerbIterator& other) {
+            SkASSERT(fSegments.data() != other.fSegments.data() ||
+                     fSegments.size() == other.fSegments.size());
+            return fSegments.data() == other.fSegments.data();
+        }
+
+        bool operator!=(const ForwardVerbIterator& other) {
+            return !((*this) == other);
+        }
+
+    private:
+        friend class SkContourMeasure;
+
+        ForwardVerbIterator(SkSpan<const Segment> segs, SkSpan<const SkPoint> pts)
+            : fSegments(LastSegForCurrentVerb(segs))
+            , fPts(pts) {}
+
+        static SkSpan<const Segment> LastSegForCurrentVerb(const SkSpan<const Segment>& segs) {
+            size_t i = 1;
+            while (i < segs.size() && segs[0].fPtIndex == segs[i].fPtIndex) {
+                ++i;
+            }
+
+            return segs.subspan(i - 1);
+        }
+
+        // Remaining segments for forward iteration. The first segment in the span is
+        // adjusted to always point to the last segment of the current verb, such that its distance
+        // corresponds to the verb distance.
+        SkSpan<const Segment> fSegments;
+
+        // All path points (indexed in segments).
+        SkSpan<const SkPoint> fPts;
+    };
+
+    ForwardVerbIterator begin() const {
+        return ForwardVerbIterator(fSegments, fPts);
+    }
+    ForwardVerbIterator end() const {
+        return ForwardVerbIterator(SkSpan(fSegments.end(), 0), fPts);
+    }
+
 private:
     struct Segment {
         SkScalar    fDistance;  // total distance up to this point

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

@@ -0,0 +1,48 @@
+/*
+* Copyright 2024 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_H_
+#define SKFONTSCANNER_H_
+
+#include "include/core/SkFontArguments.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkFixed.h"
+#include "include/private/base/SkNoncopyable.h"
+#include "include/private/base/SkTArray.h"
+class SkFontStyle;
+class SkStreamAsset;
+class SkString;
+class SkTypeface;
+
+class SkFontScanner : public SkNoncopyable {
+public:
+    virtual ~SkFontScanner() = default;
+    struct AxisDefinition {
+        SkFourByteTag fTag;
+        SkScalar fMinimum;
+        SkScalar fDefault;
+        SkScalar fMaximum;
+    };
+    typedef skia_private::STArray<4, AxisDefinition, true> AxisDefinitions;
+
+    virtual bool scanFile(SkStreamAsset* stream, int* numFaces) const = 0;
+    virtual bool scanFace(SkStreamAsset* stream, int faceIndex, int* numInstances) const = 0;
+    /* instanceIndex 0 is the default instance, 1 to numInstances are the named instances. */
+    virtual bool scanInstance(SkStreamAsset* stream,
+                              int faceIndex,
+                              int instanceIndex,
+                              SkString* name,
+                              SkFontStyle* style,
+                              bool* isFixedPitch,
+                              AxisDefinitions* axes) const = 0;
+    virtual sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream,
+                                             const SkFontArguments& args) const = 0;
+    virtual SkFourByteTag getFactoryId() const = 0;
+};
+
+#endif // SKFONTSCANNER_H_

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

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

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

@@ -26,6 +26,7 @@
 #include <tuple>
 #include <type_traits>
 
+struct SkArc;
 class SkData;
 class SkPathRef;
 class SkRRect;
@@ -280,6 +281,16 @@ public:
     */
     bool isRRect(SkRRect* rrect) const;
 
+    /** Returns true if path is representable as an oval arc. In other words, could this
+        path be drawn using SkCanvas::drawArc.
+
+        arc  receives parameters of arc
+
+       @param arc  storage for arc; may be nullptr
+       @return     true if SkPath contains only a single arc from an oval
+    */
+    bool isArc(SkArc* arc) const;
+
     /** Sets SkPath to its initial state.
         Removes verb array, SkPoint array, and weights, and sets FillType to kWinding.
         Internal storage associated with SkPath is released.