@shopify/react-native-skia 0.0.135

package/cpp/skia/include/gpu/vk/GrVkTypes.h

@@ -0,0 +1,187 @@
+
+/*
+ * 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 GrVkTypes_DEFINED
+#define GrVkTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/gpu/vk/GrVkVulkan.h"
+
+#ifndef VK_VERSION_1_1
+#error Skia requires the use of Vulkan 1.1 headers
+#endif
+
+#include <functional>
+#include "include/gpu/GrTypes.h"
+
+typedef intptr_t GrVkBackendMemory;
+
+/**
+ * Types for interacting with Vulkan resources created externally to Skia. GrBackendObjects for
+ * Vulkan textures are really const GrVkImageInfo*
+ */
+struct GrVkAlloc {
+    // can be VK_NULL_HANDLE iff is an RT and is borrowed
+    VkDeviceMemory    fMemory = VK_NULL_HANDLE;
+    VkDeviceSize      fOffset = 0;
+    VkDeviceSize      fSize = 0;  // this can be indeterminate iff Tex uses borrow semantics
+    uint32_t          fFlags = 0;
+    GrVkBackendMemory fBackendMemory = 0; // handle to memory allocated via GrVkMemoryAllocator.
+
+    enum Flag {
+        kNoncoherent_Flag     = 0x1,   // memory must be flushed to device after mapping
+        kMappable_Flag        = 0x2,   // memory is able to be mapped.
+        kLazilyAllocated_Flag = 0x4,   // memory was created with lazy allocation
+    };
+
+    bool operator==(const GrVkAlloc& that) const {
+        return fMemory == that.fMemory && fOffset == that.fOffset && fSize == that.fSize &&
+               fFlags == that.fFlags && fUsesSystemHeap == that.fUsesSystemHeap;
+    }
+
+private:
+    friend class GrVkHeap; // For access to usesSystemHeap
+    bool fUsesSystemHeap = false;
+};
+
+// This struct is used to pass in the necessary information to create a VkSamplerYcbcrConversion
+// object for an VkExternalFormatANDROID.
+struct GrVkYcbcrConversionInfo {
+    bool operator==(const GrVkYcbcrConversionInfo& that) const {
+        // Invalid objects are not required to have all other fields initialized or matching.
+        if (!this->isValid() && !that.isValid()) {
+            return true;
+        }
+        return this->fFormat == that.fFormat &&
+               this->fExternalFormat == that.fExternalFormat &&
+               this->fYcbcrModel == that.fYcbcrModel &&
+               this->fYcbcrRange == that.fYcbcrRange &&
+               this->fXChromaOffset == that.fXChromaOffset &&
+               this->fYChromaOffset == that.fYChromaOffset &&
+               this->fChromaFilter == that.fChromaFilter &&
+               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
+    }
+    bool operator!=(const GrVkYcbcrConversionInfo& that) const { return !(*this == that); }
+
+    bool isValid() const { return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; }
+
+    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
+    // a valid image format otherwise.
+    VkFormat fFormat = VK_FORMAT_UNDEFINED;
+
+    // The external format. Must be non-zero for external images, zero otherwise.
+    // Should be compatible to be used in a VkExternalFormatANDROID struct.
+    uint64_t fExternalFormat = 0;
+
+    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+    VkSamplerYcbcrRange fYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+    VkChromaLocation fXChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkChromaLocation fYChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkFilter fChromaFilter = VK_FILTER_NEAREST;
+    VkBool32 fForceExplicitReconstruction = false;
+
+    // For external images format features here should be those returned by a call to
+    // vkAndroidHardwareBufferFormatPropertiesANDROID
+    VkFormatFeatureFlags fFormatFeatures = 0;
+};
+
+/*
+ * When wrapping a GrBackendTexture or GrBackendRendenderTarget, the fCurrentQueueFamily should
+ * either be VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_EXTERNAL, or VK_QUEUE_FAMILY_FOREIGN_EXT. If
+ * fSharingMode is VK_SHARING_MODE_EXCLUSIVE then fCurrentQueueFamily can also be the graphics
+ * queue index passed into Skia.
+ */
+struct GrVkImageInfo {
+    VkImage                  fImage = VK_NULL_HANDLE;
+    GrVkAlloc                fAlloc;
+    VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    VkImageLayout            fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    VkFormat                 fFormat = VK_FORMAT_UNDEFINED;
+    VkImageUsageFlags        fImageUsageFlags = 0;
+    uint32_t                 fSampleCount = 1;
+    uint32_t                 fLevelCount = 0;
+    uint32_t                 fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
+    GrProtected              fProtected = GrProtected::kNo;
+    GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+    VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+    bool                     fPartOfSwapchainOrAndroidWindow = false;
+#endif
+
+#if GR_TEST_UTILS
+    bool operator==(const GrVkImageInfo& that) const {
+        bool equal = fImage == that.fImage && fAlloc == that.fAlloc &&
+                     fImageTiling == that.fImageTiling &&
+                     fImageLayout == that.fImageLayout &&
+                     fFormat == that.fFormat &&
+                     fImageUsageFlags == that.fImageUsageFlags &&
+                     fSampleCount == that.fSampleCount &&
+                     fLevelCount == that.fLevelCount &&
+                     fCurrentQueueFamily == that.fCurrentQueueFamily &&
+                     fProtected == that.fProtected &&
+                     fYcbcrConversionInfo == that.fYcbcrConversionInfo &&
+                     fSharingMode == that.fSharingMode;
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+        equal = equal && (fPartOfSwapchainOrAndroidWindow == that.fPartOfSwapchainOrAndroidWindow);
+#endif
+        return equal;
+    }
+#endif
+};
+
+using GrVkGetProc = std::function<PFN_vkVoidFunction(
+        const char*, // function name
+        VkInstance,  // instance or VK_NULL_HANDLE
+        VkDevice     // device or VK_NULL_HANDLE
+        )>;
+
+/**
+ * This object is wrapped in a GrBackendDrawableInfo and passed in as an argument to
+ * drawBackendGpu() calls on an SkDrawable. The drawable will use this info to inject direct
+ * Vulkan calls into our stream of GPU draws.
+ *
+ * The SkDrawable is given a secondary VkCommandBuffer in which to record draws. The GPU backend
+ * will then execute that command buffer within a render pass it is using for its own draws. The
+ * drawable is also given the attachment of the color index, a compatible VkRenderPass, and the
+ * VkFormat of the color attachment so that it can make VkPipeline objects for the draws. The
+ * SkDrawable must not alter the state of the VkRenderpass or sub pass.
+ *
+ * Additionally, the SkDrawable may fill in the passed in fDrawBounds with the bounds of the draws
+ * that it submits to the command buffer. This will be used by the GPU backend for setting the
+ * bounds in vkCmdBeginRenderPass. If fDrawBounds is not updated, we will assume that the entire
+ * attachment may have been written to.
+ *
+ * The SkDrawable is always allowed to create its own command buffers and submit them to the queue
+ * to render offscreen textures which will be sampled in draws added to the passed in
+ * VkCommandBuffer. If this is done the SkDrawable is in charge of adding the required memory
+ * barriers to the queue for the sampled images since the Skia backend will not do this.
+ */
+struct GrVkDrawableInfo {
+    VkCommandBuffer fSecondaryCommandBuffer;
+    uint32_t        fColorAttachmentIndex;
+    VkRenderPass    fCompatibleRenderPass;
+    VkFormat        fFormat;
+    VkRect2D*       fDrawBounds;
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+    bool            fFromSwapchainOrAndroidWindow;
+#endif
+};
+
+struct GrVkSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    GrProtected fProtected = GrProtected::kNo;
+
+    VkImageTiling fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    VkFormat fFormat = VK_FORMAT_UNDEFINED;
+    VkImageUsageFlags fImageUsageFlags = 0;
+    GrVkYcbcrConversionInfo fYcbcrConversionInfo;
+    VkSharingMode fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+};
+
+#endif

package/cpp/skia/include/gpu/vk/GrVkVulkan.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrVkVulkan_DEFINED
+#define GrVkVulkan_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#if SKIA_IMPLEMENTATION || !defined(SK_VULKAN)
+#include "include/third_party/vulkan/vulkan/vulkan_core.h"
+#else
+// For google3 builds we don't set SKIA_IMPLEMENTATION so we need to make sure that the vulkan
+// headers stay up to date for our needs
+#include <vulkan/vulkan_core.h>
+#endif
+
+#ifdef SK_BUILD_FOR_ANDROID
+// This is needed to get android extensions for external memory
+#if SKIA_IMPLEMENTATION || !defined(SK_VULKAN)
+#include "include/third_party/vulkan/vulkan/vulkan_android.h"
+#else
+// For google3 builds we don't set SKIA_IMPLEMENTATION so we need to make sure that the vulkan
+// headers stay up to date for our needs
+#include <vulkan/vulkan_android.h>
+#endif
+#endif
+
+#endif

package/cpp/skia/include/pathops/SkPathOps.h

@@ -0,0 +1,113 @@
+/*
+ * 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 SkPathOps_DEFINED
+#define SkPathOps_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkTArray.h"
+#include "include/private/SkTDArray.h"
+
+class SkPath;
+struct SkRect;
+
+
+// FIXME: move everything below into the SkPath class
+/**
+  *  The logical operations that can be performed when combining two paths.
+  */
+enum SkPathOp {
+    kDifference_SkPathOp,         //!< subtract the op path from the first path
+    kIntersect_SkPathOp,          //!< intersect the two paths
+    kUnion_SkPathOp,              //!< union (inclusive-or) the two paths
+    kXOR_SkPathOp,                //!< exclusive-or the two paths
+    kReverseDifference_SkPathOp,  //!< subtract the first path from the op path
+};
+
+/** Set this path to the result of applying the Op to this path and the
+    specified path: this = (this op operand).
+    The resulting path will be constructed from non-overlapping contours.
+    The curve order is reduced where possible so that cubics may be turned
+    into quadratics, and quadratics maybe turned into lines.
+
+    Returns true if operation was able to produce a result;
+    otherwise, result is unmodified.
+
+    @param one The first operand (for difference, the minuend)
+    @param two The second operand (for difference, the subtrahend)
+    @param op The operator to apply.
+    @param result The product of the operands. The result may be one of the
+                  inputs.
+    @return True if the operation succeeded.
+  */
+bool SK_API Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result);
+
+/** Set this path to a set of non-overlapping contours that describe the
+    same area as the original path.
+    The curve order is reduced where possible so that cubics may
+    be turned into quadratics, and quadratics maybe turned into lines.
+
+    Returns true if operation was able to produce a result;
+    otherwise, result is unmodified.
+
+    @param path The path to simplify.
+    @param result The simplified path. The result may be the input.
+    @return True if simplification succeeded.
+  */
+bool SK_API Simplify(const SkPath& path, SkPath* result);
+
+/** Set the resulting rectangle to the tight bounds of the path.
+
+    @param path The path measured.
+    @param result The tight bounds of the path.
+    @return True if the bounds could be computed.
+  */
+bool SK_API TightBounds(const SkPath& path, SkRect* result);
+
+/** Set the result with fill type winding to area equivalent to path.
+    Returns true if successful. Does not detect if path contains contours which
+    contain self-crossings or cross other contours; in these cases, may return
+    true even though result does not fill same area as path.
+
+    Returns true if operation was able to produce a result;
+    otherwise, result is unmodified. The result may be the input.
+
+    @param path The path typically with fill type set to even odd.
+    @param result The equivalent path with fill type set to winding.
+    @return True if winding path was set.
+  */
+bool SK_API AsWinding(const SkPath& path, SkPath* result);
+
+/** Perform a series of path operations, optimized for unioning many paths together.
+  */
+class SK_API SkOpBuilder {
+public:
+    /** Add one or more paths and their operand. The builder is empty before the first
+        path is added, so the result of a single add is (emptyPath OP path).
+
+        @param path The second operand.
+        @param _operator The operator to apply to the existing and supplied paths.
+     */
+    void add(const SkPath& path, SkPathOp _operator);
+
+    /** Computes the sum of all paths and operands, and resets the builder to its
+        initial state.
+
+        @param result The product of the operands.
+        @return True if the operation succeeded.
+      */
+    bool resolve(SkPath* result);
+
+private:
+    SkTArray<SkPath> fPathRefs;
+    SkTDArray<SkPathOp> fOps;
+
+    static bool FixWinding(SkPath* path);
+    static void ReversePath(SkPath* path);
+    void reset();
+};
+
+#endif

package/cpp/skia/include/ports/SkCFObject.h

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCFObject_DEFINED
+#define SkCFObject_DEFINED
+
+#ifdef __APPLE__
+
+#include "include/core/SkTypes.h"
+
+#include <cstddef>      // std::nullptr_t
+
+#import <CoreFoundation/CoreFoundation.h>
+
+/**
+ * Wrapper class for managing lifetime of CoreFoundation objects. It will call
+ * CFRetain and CFRelease appropriately on creation, assignment, and deletion.
+ * Based on sk_sp<>.
+ */
+template <typename T> static inline T SkCFSafeRetain(T obj) {
+    if (obj) {
+        CFRetain(obj);
+    }
+    return obj;
+}
+
+template <typename T> static inline void SkCFSafeRelease(T obj) {
+    if (obj) {
+        CFRelease(obj);
+    }
+}
+
+template <typename T> class sk_cfp {
+public:
+    using element_type = T;
+
+    constexpr sk_cfp() {}
+    constexpr sk_cfp(std::nullptr_t) {}
+
+    /**
+     *  Shares the underlying object by calling CFRetain(), so that both the argument and the newly
+     *  created sk_cfp both have a reference to it.
+     */
+    sk_cfp(const sk_cfp<T>& that) : fObject(SkCFSafeRetain(that.get())) {}
+
+    /**
+     *  Move the underlying object from the argument to the newly created sk_cfp. Afterwards only
+     *  the new sk_cfp will have a reference to the object, and the argument will point to null.
+     *  No call to CFRetain() or CFRelease() will be made.
+     */
+    sk_cfp(sk_cfp<T>&& that) : fObject(that.release()) {}
+
+    /**
+     *  Adopt the bare object into the newly created sk_cfp.
+     *  No call to CFRetain() or CFRelease() will be made.
+     */
+    explicit sk_cfp(T obj) {
+        fObject = obj;
+    }
+
+    /**
+     *  Calls CFRelease() on the underlying object pointer.
+     */
+    ~sk_cfp() {
+        SkCFSafeRelease(fObject);
+        SkDEBUGCODE(fObject = nil);
+    }
+
+    sk_cfp<T>& operator=(std::nullptr_t) { this->reset(); return *this; }
+
+    /**
+     *  Shares the underlying object referenced by the argument by calling CFRetain() on it. If this
+     *  sk_cfp previously had a reference to an object (i.e. not null) it will call CFRelease()
+     *  on that object.
+     */
+    sk_cfp<T>& operator=(const sk_cfp<T>& that) {
+        if (this != &that) {
+            this->reset(SkCFSafeRetain(that.get()));
+        }
+        return *this;
+    }
+
+    /**
+     *  Move the underlying object from the argument to the sk_cfp. If the sk_cfp
+     * previously held a reference to another object, CFRelease() will be called on that object.
+     * No call to CFRetain() will be made.
+     */
+    sk_cfp<T>& operator=(sk_cfp<T>&& that) {
+        this->reset(that.release());
+        return *this;
+    }
+
+    explicit operator bool() const { return this->get() != nil; }
+
+    T get() const { return fObject; }
+    T operator*() const {
+        SkASSERT(fObject);
+        return fObject;
+    }
+
+    /**
+     *  Adopt the new object, and call CFRelease() on any previously held object (if not null).
+     *  No call to CFRetain() will be made.
+     */
+    void reset(T object = nil) {
+        // Need to unref after assigning, see
+        // http://wg21.cmeerw.net/lwg/issue998
+        // http://wg21.cmeerw.net/lwg/issue2262
+        T oldObject = fObject;
+        fObject = object;
+        SkCFSafeRelease(oldObject);
+    }
+
+    /**
+     *  Shares the new object by calling CFRetain() on it. If this sk_cfp previously had a
+     *  reference to an object (i.e. not null) it will call CFRelease() on that object.
+     */
+    void retain(T object) {
+        if (fObject != object) {
+            this->reset(SkCFSafeRetain(object));
+        }
+    }
+
+    /**
+     *  Return the original object, and set the internal object to nullptr.
+     *  The caller must assume ownership of the object, and manage its reference count directly.
+     *  No call to CFRelease() will be made.
+     */
+    T SK_WARN_UNUSED_RESULT release() {
+        T obj = fObject;
+        fObject = nil;
+        return obj;
+    }
+
+private:
+    T fObject = nil;
+};
+
+template <typename T> inline bool operator==(const sk_cfp<T>& a,
+                                             const sk_cfp<T>& b) {
+    return a.get() == b.get();
+}
+template <typename T> inline bool operator==(const sk_cfp<T>& a,
+                                             std::nullptr_t) {
+    return !a;
+}
+template <typename T> inline bool operator==(std::nullptr_t,
+                                             const sk_cfp<T>& b) {
+    return !b;
+}
+
+template <typename T> inline bool operator!=(const sk_cfp<T>& a,
+                                             const sk_cfp<T>& b) {
+    return a.get() != b.get();
+}
+template <typename T> inline bool operator!=(const sk_cfp<T>& a,
+                                             std::nullptr_t) {
+    return static_cast<bool>(a);
+}
+template <typename T> inline bool operator!=(std::nullptr_t,
+                                             const sk_cfp<T>& b) {
+    return static_cast<bool>(b);
+}
+
+/*
+ *  Returns a sk_cfp wrapping the provided object AND calls retain on it (if not null).
+ *
+ *  This is different than the semantics of the constructor for sk_cfp, which just wraps the
+ *  object, effectively "adopting" it.
+ */
+template <typename T> sk_cfp<T> sk_ret_cfp(T obj) {
+    return sk_cfp<T>(SkCFSafeRetain(obj));
+}
+
+#endif  // __APPLE__
+#endif  // SkCFObject_DEFINED

package/cpp/skia/include/ports/SkFontConfigInterface.h

@@ -0,0 +1,115 @@
+/*
+ * 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 SkFontConfigInterface_DEFINED
+#define SkFontConfigInterface_DEFINED
+
+#include "include/core/SkFontStyle.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkStream.h"
+#include "include/core/SkTypeface.h"
+
+class SkFontMgr;
+
+/**
+ *  \class SkFontConfigInterface
+ *
+ *  A simple interface for remotable font management.
+ *  The global instance can be found with RefGlobal().
+ */
+class SK_API SkFontConfigInterface : public SkRefCnt {
+public:
+
+    /**
+     *  Returns the global SkFontConfigInterface instance. If it is not
+     *  nullptr, calls ref() on it. The caller must balance this with a call to
+     *  unref(). The default SkFontConfigInterface is the result of calling
+     *  GetSingletonDirectInterface.
+     */
+    static sk_sp<SkFontConfigInterface> RefGlobal();
+
+    /**
+     *  Replace the current global instance with the specified one.
+     */
+    static void SetGlobal(sk_sp<SkFontConfigInterface> fc);
+
+    /**
+     *  This should be treated as private to the impl of SkFontConfigInterface.
+     *  Callers should not change or expect any particular values. It is meant
+     *  to be a union of possible storage types to aid the impl.
+     */
+    struct FontIdentity {
+        FontIdentity() : fID(0), fTTCIndex(0) {}
+
+        bool operator==(const FontIdentity& other) const {
+            return fID == other.fID &&
+                   fTTCIndex == other.fTTCIndex &&
+                   fString == other.fString;
+        }
+        bool operator!=(const FontIdentity& other) const {
+            return !(*this == other);
+        }
+
+        uint32_t    fID;
+        int32_t     fTTCIndex;
+        SkString    fString;
+        SkFontStyle fStyle;
+
+        // If buffer is NULL, just return the number of bytes that would have
+        // been written. Will pad contents to a multiple of 4.
+        size_t writeToMemory(void* buffer = nullptr) const;
+
+        // Recreate from a flattened buffer, returning the number of bytes read.
+        size_t readFromMemory(const void* buffer, size_t length);
+    };
+
+    /**
+     *  Given a familyName and style, find the best match.
+     *
+     *  If a match is found, return true and set its outFontIdentifier.
+     *      If outFamilyName is not null, assign the found familyName to it
+     *          (which may differ from the requested familyName).
+     *      If outStyle is not null, assign the found style to it
+     *          (which may differ from the requested style).
+     *
+     *  If a match is not found, return false, and ignore all out parameters.
+     */
+    virtual bool matchFamilyName(const char familyName[],
+                                 SkFontStyle requested,
+                                 FontIdentity* outFontIdentifier,
+                                 SkString* outFamilyName,
+                                 SkFontStyle* outStyle) = 0;
+
+    /**
+     *  Given a FontRef, open a stream to access its data, or return null
+     *  if the FontRef's data is not available. The caller is responsible for
+     *  deleting the stream when it is done accessing the data.
+     */
+    virtual SkStreamAsset* openStream(const FontIdentity&) = 0;
+
+    /**
+     *  Return an SkTypeface for the given FontIdentity.
+     *
+     *  The default implementation simply returns a new typeface built using data obtained from
+     *  openStream(), but derived classes may implement more complex caching schemes.
+     */
+    virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity) {
+        return SkTypeface::MakeFromStream(std::unique_ptr<SkStreamAsset>(this->openStream(identity)),
+                                          identity.fTTCIndex);
+
+    }
+
+    /**
+     *  Return a singleton instance of a direct subclass that calls into
+     *  libfontconfig. This does not affect the refcnt of the returned instance.
+     */
+    static SkFontConfigInterface* GetSingletonDirectInterface();
+
+    using INHERITED = SkRefCnt;
+};
+
+#endif

package/cpp/skia/include/ports/SkFontMgr_FontConfigInterface.h

@@ -0,0 +1,20 @@
+/*
+ * 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 SkFontMgr_FontConfigInterface_DEFINED
+#define SkFontMgr_FontConfigInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+class SkFontMgr;
+class SkFontConfigInterface;
+
+/** Creates a SkFontMgr which wraps a SkFontConfigInterface. */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci);
+
+#endif // #ifndef SkFontMgr_FontConfigInterface_DEFINED

package/cpp/skia/include/ports/SkFontMgr_android.h

@@ -0,0 +1,45 @@
+/*
+ * 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 SkFontMgr_android_DEFINED
+#define SkFontMgr_android_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkFontMgr;
+
+struct SkFontMgr_Android_CustomFonts {
+    /** When specifying custom fonts, indicates how to use system fonts. */
+    enum SystemFontUse {
+        kOnlyCustom, /** Use only custom fonts. NDK compliant. */
+        kPreferCustom, /** Use custom fonts before system fonts. */
+        kPreferSystem /** Use system fonts before custom fonts. */
+    };
+    /** Whether or not to use system fonts. */
+    SystemFontUse fSystemFontUse;
+
+    /** Base path to resolve relative font file names. If a directory, should end with '/'. */
+    const char* fBasePath;
+
+    /** Optional custom configuration file to use. */
+    const char* fFontsXml;
+
+    /** Optional custom configuration file for fonts which provide fallback.
+     *  In the new style (version > 21) fontsXml format is used, this should be NULL.
+     */
+    const char* fFallbackFontsXml;
+
+    /** Optional custom flag. If set to true the SkFontMgr will acquire all requisite
+     *  system IO resources on initialization.
+     */
+    bool fIsolated;
+};
+
+/** Create a font manager for Android. If 'custom' is NULL, use only system fonts. */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom);
+
+#endif // SkFontMgr_android_DEFINED