@shopify/react-native-skia 0.0.135

package/cpp/skia/include/utils/SkCanvasStateUtils.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCanvasStateUtils_DEFINED
+#define SkCanvasStateUtils_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkCanvas;
+class SkCanvasState;
+
+/**
+ * A set of functions that are useful for copying the state of an SkCanvas
+ * across a library boundary where the Skia library on the other side of the
+ * boundary may be newer. The expected usage is outline below...
+ *
+ *                          Lib Boundary
+ * CaptureCanvasState(...)      |||
+ *   SkCanvas --> SkCanvasState |||
+ *                              ||| CreateFromCanvasState(...)
+ *                              |||   SkCanvasState --> SkCanvas`
+ *                              ||| Draw into SkCanvas`
+ *                              ||| Unref SkCanvas`
+ * ReleaseCanvasState(...)      |||
+ *
+ */
+class SK_API SkCanvasStateUtils {
+public:
+    /**
+     * Captures the current state of the canvas into an opaque ptr that is safe
+     * to pass to a different instance of Skia (which may be the same version,
+     * or may be newer). The function will return NULL in the event that one of the
+     * following conditions are true.
+     *  1) the canvas device type is not supported (currently only raster is supported)
+     *  2) the canvas clip type is not supported (currently only non-AA clips are supported)
+     *
+     * It is recommended that the original canvas also not be used until all
+     * canvases that have been created using its captured state have been dereferenced.
+     *
+     * Finally, it is important to note that any draw filters attached to the
+     * canvas are NOT currently captured.
+     *
+     * @param canvas The canvas you wish to capture the current state of.
+     * @return NULL or an opaque ptr that can be passed to CreateFromCanvasState
+     *         to reconstruct the canvas. The caller is responsible for calling
+     *         ReleaseCanvasState to free the memory associated with this state.
+     */
+    static SkCanvasState* CaptureCanvasState(SkCanvas* canvas);
+
+    /**
+     * Create a new SkCanvas from the captured state of another SkCanvas. The
+     * function will return NULL in the event that one of the
+     * following conditions are true.
+     *  1) the captured state is in an unrecognized format
+     *  2) the captured canvas device type is not supported
+     *
+     * @param state Opaque object created by CaptureCanvasState.
+     * @return NULL or an SkCanvas* whose devices and matrix/clip state are
+     *         identical to the captured canvas. The caller is responsible for
+     *         calling unref on the SkCanvas.
+     */
+    static std::unique_ptr<SkCanvas> MakeFromCanvasState(const SkCanvasState* state);
+
+    /**
+     * Free the memory associated with the captured canvas state.  The state
+     * should not be released until all SkCanvas objects created using that
+     * state have been dereferenced. Must be called from the same library
+     * instance that created the state via CaptureCanvasState.
+     *
+     * @param state The captured state you wish to dispose of.
+     */
+    static void ReleaseCanvasState(SkCanvasState* state);
+};
+
+#endif

package/cpp/skia/include/utils/SkCustomTypeface.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCustomTypeface_DEFINED
+#define SkCustomTypeface_DEFINED
+
+#include "include/core/SkFontMetrics.h"
+#include "include/core/SkFontStyle.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <vector>
+
+class SkImage;
+class SkPaint;
+class SkPicture;
+class SkStream;
+class SkTypeface;
+
+class SkCustomTypefaceBuilder {
+public:
+    SkCustomTypefaceBuilder();
+
+    void setGlyph(SkGlyphID, float advance, const SkPath&);
+    void setGlyph(SkGlyphID, float advance, const SkPath&, const SkPaint&);
+    void setGlyph(SkGlyphID, float advance, sk_sp<SkImage>, float scale);
+    void setGlyph(SkGlyphID, float advance, sk_sp<SkPicture>);
+
+    void setMetrics(const SkFontMetrics& fm, float scale = 1);
+    void setFontStyle(SkFontStyle);
+
+    sk_sp<SkTypeface> detach();
+
+private:
+    std::vector<SkPath> fPaths;
+    std::vector<float>  fAdvances;
+    SkFontMetrics       fMetrics;
+    SkFontStyle         fStyle;
+
+    static sk_sp<SkTypeface> Deserialize(SkStream*);
+
+    friend class SkTypeface;
+};
+
+#endif

package/cpp/skia/include/utils/SkEventTracer.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2014 Google Inc. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEventTracer_DEFINED
+#define SkEventTracer_DEFINED
+
+// The class in this header defines the interface between Skia's internal
+// tracing macros and an external entity (e.g., Chrome) that will consume them.
+// Such an entity should subclass SkEventTracer and provide an instance of
+// that event to SkEventTracer::SetInstance.
+
+// If you're looking for the tracing macros to instrument Skia itself, those
+// live in src/core/SkTraceEvent.h
+
+#include "include/core/SkTypes.h"
+
+class SK_API SkEventTracer {
+public:
+
+    typedef uint64_t Handle;
+
+    /**
+     * If this is the first call to SetInstance or GetInstance then the passed instance is
+     * installed and true is returned. Otherwise, false is returned. In either case ownership of the
+     * tracer is transferred and it will be deleted when no longer needed.
+     */
+    static bool SetInstance(SkEventTracer*);
+
+    /**
+     * Gets the event tracer. If this is the first call to SetInstance or GetIntance then a default
+     * event tracer is installed and returned.
+     */
+    static SkEventTracer* GetInstance();
+
+    virtual ~SkEventTracer() = default;
+
+    // The pointer returned from GetCategoryGroupEnabled() points to a
+    // value with zero or more of the following bits. Used in this class only.
+    // The TRACE_EVENT macros should only use the value as a bool.
+    // These values must be in sync with macro values in trace_event.h in chromium.
+    enum CategoryGroupEnabledFlags {
+        // Category group enabled for the recording mode.
+        kEnabledForRecording_CategoryGroupEnabledFlags = 1 << 0,
+        // Category group enabled for the monitoring mode.
+        kEnabledForMonitoring_CategoryGroupEnabledFlags = 1 << 1,
+        // Category group enabled by SetEventCallbackEnabled().
+        kEnabledForEventCallback_CategoryGroupEnabledFlags = 1 << 2,
+    };
+
+    virtual const uint8_t* getCategoryGroupEnabled(const char* name) = 0;
+    virtual const char* getCategoryGroupName(const uint8_t* categoryEnabledFlag) = 0;
+
+    virtual SkEventTracer::Handle
+        addTraceEvent(char phase,
+                      const uint8_t* categoryEnabledFlag,
+                      const char* name,
+                      uint64_t id,
+                      int32_t numArgs,
+                      const char** argNames,
+                      const uint8_t* argTypes,
+                      const uint64_t* argValues,
+                      uint8_t flags) = 0;
+
+    virtual void
+        updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                 const char* name,
+                                 SkEventTracer::Handle handle) = 0;
+
+protected:
+    SkEventTracer() = default;
+    SkEventTracer(const SkEventTracer&) = delete;
+    SkEventTracer& operator=(const SkEventTracer&) = delete;
+};
+
+#endif // SkEventTracer_DEFINED

package/cpp/skia/include/utils/SkNWayCanvas.h

@@ -0,0 +1,126 @@
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkNWayCanvas_DEFINED
+#define SkNWayCanvas_DEFINED
+
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkCanvasVirtualEnforcer.h"
+#include "include/core/SkClipOp.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkM44.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkTDArray.h"
+#include "include/utils/SkNoDrawCanvas.h"
+
+class SkData;
+class SkDrawable;
+class SkGlyphRunList;
+class SkImage;
+class SkMatrix;
+class SkPaint;
+class SkPath;
+class SkPicture;
+class SkRRect;
+class SkRegion;
+class SkShader;
+class SkTextBlob;
+class SkVertices;
+struct SkDrawShadowRec;
+struct SkPoint;
+struct SkRSXform;
+struct SkRect;
+
+#if SK_SUPPORT_GPU
+class GrSlug;
+#endif
+
+class SK_API SkNWayCanvas : public SkCanvasVirtualEnforcer<SkNoDrawCanvas> {
+public:
+    SkNWayCanvas(int width, int height);
+    ~SkNWayCanvas() override;
+
+    virtual void addCanvas(SkCanvas*);
+    virtual void removeCanvas(SkCanvas*);
+    virtual void removeAll();
+
+protected:
+    SkTDArray<SkCanvas*> fList;
+
+    void willSave() override;
+    SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) override;
+    bool onDoSaveBehind(const SkRect*) override;
+    void willRestore() override;
+
+    void didConcat44(const SkM44&) override;
+    void didSetM44(const SkM44&) override;
+    void didScale(SkScalar, SkScalar) override;
+    void didTranslate(SkScalar, SkScalar) override;
+
+    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
+    void onDrawGlyphRunList(const SkGlyphRunList&, const SkPaint&) override;
+    void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
+                        const SkPaint& paint) override;
+#if SK_SUPPORT_GPU
+    void onDrawSlug(const GrSlug* slug) override;
+#endif
+    void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
+                     const SkPoint texCoords[4], SkBlendMode, const SkPaint& paint) override;
+
+    void onDrawPaint(const SkPaint&) override;
+    void onDrawBehind(const SkPaint&) override;
+    void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+    void onDrawRect(const SkRect&, const SkPaint&) override;
+    void onDrawRegion(const SkRegion&, const SkPaint&) override;
+    void onDrawOval(const SkRect&, const SkPaint&) override;
+    void onDrawArc(const SkRect&, SkScalar, SkScalar, bool, const SkPaint&) override;
+    void onDrawRRect(const SkRRect&, const SkPaint&) override;
+    void onDrawPath(const SkPath&, const SkPaint&) override;
+
+    void onDrawImage2(const SkImage*, SkScalar, SkScalar, const SkSamplingOptions&,
+                      const SkPaint*) override;
+    void onDrawImageRect2(const SkImage*, const SkRect&, const SkRect&, const SkSamplingOptions&,
+                          const SkPaint*, SrcRectConstraint) override;
+    void onDrawImageLattice2(const SkImage*, const Lattice&, const SkRect&, SkFilterMode,
+                             const SkPaint*) override;
+    void onDrawAtlas2(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
+                  SkBlendMode, const SkSamplingOptions&, const SkRect*, const SkPaint*) override;
+
+    void onDrawVerticesObject(const SkVertices*, SkBlendMode, const SkPaint&) override;
+    void onDrawShadowRec(const SkPath&, const SkDrawShadowRec&) override;
+
+    void onClipRect(const SkRect&, SkClipOp, ClipEdgeStyle) override;
+    void onClipRRect(const SkRRect&, SkClipOp, ClipEdgeStyle) override;
+    void onClipPath(const SkPath&, SkClipOp, ClipEdgeStyle) override;
+    void onClipShader(sk_sp<SkShader>, SkClipOp) override;
+    void onClipRegion(const SkRegion&, SkClipOp) override;
+    void onResetClip() override;
+
+    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
+    void onDrawDrawable(SkDrawable*, const SkMatrix*) override;
+    void onDrawAnnotation(const SkRect&, const char[], SkData*) override;
+
+    void onDrawEdgeAAQuad(const SkRect&, const SkPoint[4], QuadAAFlags, const SkColor4f&,
+                          SkBlendMode) override;
+    void onDrawEdgeAAImageSet2(const ImageSetEntry[], int count, const SkPoint[], const SkMatrix[],
+                               const SkSamplingOptions&,const SkPaint*, SrcRectConstraint) override;
+
+    void onFlush() override;
+
+    class Iter;
+
+private:
+    using INHERITED = SkCanvasVirtualEnforcer<SkNoDrawCanvas>;
+};
+
+
+#endif

package/cpp/skia/include/utils/SkNoDrawCanvas.h

@@ -0,0 +1,80 @@
+/*
+ * 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 SkNoDrawCanvas_DEFINED
+#define SkNoDrawCanvas_DEFINED
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkCanvasVirtualEnforcer.h"
+
+struct SkIRect;
+
+// SkNoDrawCanvas is a helper for SkCanvas subclasses which do not need to
+// actually rasterize (e.g., analysis of the draw calls).
+//
+// It provides the following simplifications:
+//
+//   * not backed by any device/pixels
+//   * conservative clipping (clipping calls only use rectangles)
+//
+class SK_API SkNoDrawCanvas : public SkCanvasVirtualEnforcer<SkCanvas> {
+public:
+    SkNoDrawCanvas(int width, int height);
+    SkNoDrawCanvas(const SkIRect&);
+
+    explicit SkNoDrawCanvas(sk_sp<SkBaseDevice> device);
+
+    // Optimization to reset state to be the same as after construction.
+    void resetCanvas(int w, int h)        { this->resetForNextPicture(SkIRect::MakeWH(w, h)); }
+    void resetCanvas(const SkIRect& rect) { this->resetForNextPicture(rect); }
+
+protected:
+    SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec& rec) override;
+    bool onDoSaveBehind(const SkRect*) override;
+
+    // No-op overrides for aborting rasterization earlier than SkNullBlitter.
+    void onDrawAnnotation(const SkRect&, const char[], SkData*) override {}
+    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override {}
+    void onDrawDrawable(SkDrawable*, const SkMatrix*) override {}
+    void onDrawTextBlob(const SkTextBlob*, SkScalar, SkScalar, const SkPaint&) override {}
+    void onDrawPatch(const SkPoint[12], const SkColor[4], const SkPoint[4], SkBlendMode,
+                     const SkPaint&) override {}
+
+    void onDrawPaint(const SkPaint&) override {}
+    void onDrawBehind(const SkPaint&) override {}
+    void onDrawPoints(PointMode, size_t, const SkPoint[], const SkPaint&) override {}
+    void onDrawRect(const SkRect&, const SkPaint&) override {}
+    void onDrawRegion(const SkRegion&, const SkPaint&) override {}
+    void onDrawOval(const SkRect&, const SkPaint&) override {}
+    void onDrawArc(const SkRect&, SkScalar, SkScalar, bool, const SkPaint&) override {}
+    void onDrawRRect(const SkRRect&, const SkPaint&) override {}
+    void onDrawPath(const SkPath&, const SkPaint&) override {}
+
+    void onDrawImage2(const SkImage*, SkScalar, SkScalar, const SkSamplingOptions&,
+                      const SkPaint*) override {}
+    void onDrawImageRect2(const SkImage*, const SkRect&, const SkRect&, const SkSamplingOptions&,
+                          const SkPaint*, SrcRectConstraint) override {}
+    void onDrawImageLattice2(const SkImage*, const Lattice&, const SkRect&, SkFilterMode,
+                             const SkPaint*) override {}
+    void onDrawAtlas2(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
+                  SkBlendMode, const SkSamplingOptions&, const SkRect*, const SkPaint*) override {}
+
+    void onDrawVerticesObject(const SkVertices*, SkBlendMode, const SkPaint&) override {}
+    void onDrawShadowRec(const SkPath&, const SkDrawShadowRec&) override {}
+    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override {}
+
+    void onDrawEdgeAAQuad(const SkRect&, const SkPoint[4], QuadAAFlags, const SkColor4f&,
+                          SkBlendMode) override {}
+    void onDrawEdgeAAImageSet2(const ImageSetEntry[], int, const SkPoint[], const SkMatrix[],
+                               const SkSamplingOptions&, const SkPaint*,
+                               SrcRectConstraint) override {}
+
+private:
+    using INHERITED = SkCanvasVirtualEnforcer<SkCanvas>;
+};
+
+#endif // SkNoDrawCanvas_DEFINED

package/cpp/skia/include/utils/SkNullCanvas.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkNullCanvas_DEFINED
+#define SkNullCanvas_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkCanvas;
+
+/**
+ * Creates a canvas that draws nothing. This is useful for performance testing.
+ */
+SK_API std::unique_ptr<SkCanvas> SkMakeNullCanvas();
+
+#endif

package/cpp/skia/include/utils/SkOrderedFontMgr.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkOrderedFontMgr_DEFINED
+#define SkOrderedFontMgr_DEFINED
+
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+#include <vector>
+
+class SkData;
+class SkFontStyle;
+class SkStreamAsset;
+class SkString;
+class SkTypeface;
+struct SkFontArguments;
+
+/**
+ *  Collects an order list of other font managers, and visits them in order
+ *  when a request to find or match is issued.
+ *
+ *  Note: this explicitly fails on any attempt to Make a typeface: all of
+ *  those requests will return null.
+ */
+class SK_API SkOrderedFontMgr : public SkFontMgr {
+public:
+    SkOrderedFontMgr();
+    ~SkOrderedFontMgr() override;
+
+    void append(sk_sp<SkFontMgr>);
+
+protected:
+    int onCountFamilies() const override;
+    void onGetFamilyName(int index, SkString* familyName) const override;
+    SkFontStyleSet* onCreateStyleSet(int index)const override;
+
+    SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
+
+    SkTypeface* onMatchFamilyStyle(const char familyName[], const SkFontStyle&) const override;
+    SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
+                                            const char* bcp47[], int bcp47Count,
+                                            SkUnichar character) const override;
+
+    // Note: all of these always return null
+    sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int ttcIndex) const override;
+    sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>,
+                                            int ttcIndex) const override;
+    sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset>,
+                                           const SkFontArguments&) const override;
+    sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const override;
+
+    sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const override;
+
+private:
+    std::vector<sk_sp<SkFontMgr>> fList;
+};
+
+#endif

package/cpp/skia/include/utils/SkPaintFilterCanvas.h

@@ -0,0 +1,136 @@
+/*
+ * 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 SkPaintFilterCanvas_DEFINED
+#define SkPaintFilterCanvas_DEFINED
+
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkCanvasVirtualEnforcer.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkTDArray.h"
+#include "include/utils/SkNWayCanvas.h"
+
+class GrRecordingContext;
+class SkData;
+class SkDrawable;
+class SkGlyphRunList;
+class SkImage;
+class SkMatrix;
+class SkPaint;
+class SkPath;
+class SkPicture;
+class SkPixmap;
+class SkRRect;
+class SkRegion;
+class SkSurface;
+class SkSurfaceProps;
+class SkTextBlob;
+class SkVertices;
+struct SkDrawShadowRec;
+struct SkPoint;
+struct SkRSXform;
+struct SkRect;
+
+/** \class SkPaintFilterCanvas
+
+    A utility proxy base class for implementing draw/paint filters.
+*/
+class SK_API SkPaintFilterCanvas : public SkCanvasVirtualEnforcer<SkNWayCanvas> {
+public:
+    /**
+     * The new SkPaintFilterCanvas is configured for forwarding to the
+     * specified canvas.  Also copies the target canvas matrix and clip bounds.
+     */
+    SkPaintFilterCanvas(SkCanvas* canvas);
+
+    enum Type {
+        kPicture_Type,
+    };
+
+    // Forwarded to the wrapped canvas.
+    SkISize getBaseLayerSize() const override { return proxy()->getBaseLayerSize(); }
+    GrRecordingContext* recordingContext() override { return proxy()->recordingContext(); }
+
+protected:
+    /**
+     *  Called with the paint that will be used to draw the specified type.
+     *  The implementation may modify the paint as they wish.
+     *
+     *  The result bool is used to determine whether the draw op is to be
+     *  executed (true) or skipped (false).
+     *
+     *  Note: The base implementation calls onFilter() for top-level/explicit paints only.
+     *        To also filter encapsulated paints (e.g. SkPicture, SkTextBlob), clients may need to
+     *        override the relevant methods (i.e. drawPicture, drawTextBlob).
+     */
+    virtual bool onFilter(SkPaint& paint) const = 0;
+
+    void onDrawPaint(const SkPaint&) override;
+    void onDrawBehind(const SkPaint&) override;
+    void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
+    void onDrawRect(const SkRect&, const SkPaint&) override;
+    void onDrawRRect(const SkRRect&, const SkPaint&) override;
+    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
+    void onDrawRegion(const SkRegion&, const SkPaint&) override;
+    void onDrawOval(const SkRect&, const SkPaint&) override;
+    void onDrawArc(const SkRect&, SkScalar, SkScalar, bool, const SkPaint&) override;
+    void onDrawPath(const SkPath&, const SkPaint&) override;
+
+    void onDrawImage2(const SkImage*, SkScalar, SkScalar, const SkSamplingOptions&,
+                      const SkPaint*) override;
+    void onDrawImageRect2(const SkImage*, const SkRect&, const SkRect&, const SkSamplingOptions&,
+                          const SkPaint*, SrcRectConstraint) override;
+    void onDrawImageLattice2(const SkImage*, const Lattice&, const SkRect&, SkFilterMode,
+                             const SkPaint*) override;
+    void onDrawAtlas2(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
+                     SkBlendMode, const SkSamplingOptions&, const SkRect*, const SkPaint*) override;
+
+    void onDrawVerticesObject(const SkVertices*, SkBlendMode, const SkPaint&) override;
+    void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
+                             const SkPoint texCoords[4], SkBlendMode,
+                             const SkPaint& paint) override;
+    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
+    void onDrawDrawable(SkDrawable*, const SkMatrix*) override;
+
+    void onDrawGlyphRunList(const SkGlyphRunList&, const SkPaint&) override;
+    void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
+                        const SkPaint& paint) override;
+    void onDrawAnnotation(const SkRect& rect, const char key[], SkData* value) override;
+    void onDrawShadowRec(const SkPath& path, const SkDrawShadowRec& rec) override;
+
+    void onDrawEdgeAAQuad(const SkRect&, const SkPoint[4], QuadAAFlags, const SkColor4f&,
+                          SkBlendMode) override;
+    void onDrawEdgeAAImageSet2(const ImageSetEntry[], int count, const SkPoint[], const SkMatrix[],
+                               const SkSamplingOptions&,const SkPaint*, SrcRectConstraint) override;
+
+    // Forwarded to the wrapped canvas.
+    sk_sp<SkSurface> onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override;
+    bool onPeekPixels(SkPixmap* pixmap) override;
+    bool onAccessTopLayerPixels(SkPixmap* pixmap) override;
+    SkImageInfo onImageInfo() const override;
+    bool onGetProps(SkSurfaceProps* props) const override;
+
+private:
+    class AutoPaintFilter;
+
+    SkCanvas* proxy() const { SkASSERT(fList.count() == 1); return fList[0]; }
+
+    SkPaintFilterCanvas* internal_private_asPaintFilterCanvas() const override {
+        return const_cast<SkPaintFilterCanvas*>(this);
+    }
+
+    friend class SkAndroidFrameworkUtils;
+};
+
+#endif

package/cpp/skia/include/utils/SkParse.h

@@ -0,0 +1,34 @@
+
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#ifndef SkParse_DEFINED
+#define SkParse_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SK_API SkParse {
+public:
+    static int Count(const char str[]); // number of scalars or int values
+    static int Count(const char str[], char separator);
+    static const char* FindColor(const char str[], SkColor* value);
+    static const char* FindHex(const char str[], uint32_t* value);
+    static const char* FindMSec(const char str[], SkMSec* value);
+    static const char* FindNamedColor(const char str[], size_t len, SkColor* color);
+    static const char* FindS32(const char str[], int32_t* value);
+    static const char* FindScalar(const char str[], SkScalar* value);
+    static const char* FindScalars(const char str[], SkScalar value[], int count);
+
+    static bool FindBool(const char str[], bool* value);
+    // return the index of str in list[], or -1 if not found
+    static int  FindList(const char str[], const char list[]);
+};
+
+#endif