Merge branch 'xamarin-mobile-bindings' into update-m59

diff --cc gn/core.gni
index e2bb2b0,f79cb94..8c8ec30
--- 1/gn/core.gni
--- 2/gn/core.gni
+++ b/gn/core.gni
@@@ -34,7 -34,7 +34,8 @@@ skia_core_sources = 
    "$_include/c/sk_types.h",
    "$_include/c/sk_xml.h",
    "$_include/c/sk_svg.h",
+   "$_include/c/sk_colorspace.h",
 +  "$_include/c/sk_vertices.h",
    "$_include/c/gr_context.h",
    "$_src/c/sk_bitmap.cpp",
    "$_src/c/sk_canvas.cpp",
@@@ -62,7 -62,7 +63,8 @@@
    "$_src/c/sk_typeface.cpp",
    "$_src/c/sk_xml.cpp",
    "$_src/c/sk_svg.cpp",
+   "$_src/c/sk_colorspace.cpp",
 +  "$_src/c/sk_vertices.cpp",
    "$_src/c/sk_types_priv.h",
    "$_src/c/gr_context.cpp",
    "$_src/c/sk_structs.cpp",

diff --cc include/c/sk_colorspace.h
index 0000000,77f3bec..5457df4
mode 000000,100644..100644
--- /dev/null
--- 2/include/c/sk_colorspace.h
+++ b/include/c/sk_colorspace.h
@@@ -1,0 -1,31 +1,31 @@@
 -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50, uint32_t flags);
 -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut, uint32_t flags);
 -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50, uint32_t flags);
 -SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut, uint32_t flags);
+ /*
+  * Copyright 2017 Xamarin Inc.
+  *
+  * Use of this source code is governed by a BSD-style license that can be
+  * found in the LICENSE file.
+  */
+ 
+ #ifndef sk_colorspace_DEFINED
+ #define sk_colorspace_DEFINED
+ 
+ #include "sk_types.h"
+ 
+ SK_C_PLUS_PLUS_BEGIN_GUARD
+ 
+ SK_C_API void sk_colorspace_unref(sk_colorspace_t* cColorSpace);
+ SK_C_API sk_colorspace_t* sk_colorspace_new_srgb();
+ SK_C_API sk_colorspace_t* sk_colorspace_new_srgb_linear();
+ SK_C_API sk_colorspace_t* sk_colorspace_new_icc(const void* input, size_t len);
++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50);
++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut);
++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50);
++SK_C_API sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut);
+ SK_C_API bool sk_colorspace_gamma_close_to_srgb(const sk_colorspace_t* cColorSpace);
+ SK_C_API bool sk_colorspace_gamma_is_linear(const sk_colorspace_t* cColorSpace);
+ SK_C_API bool sk_colorspace_equals(const sk_colorspace_t* src, const sk_colorspace_t* dst);
+ SK_C_API bool sk_colorspace_to_xyzd50(const sk_colorspace_t* cColorSpace, sk_matrix44_t* toXYZD50);
+ SK_C_API bool sk_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50);
+ 
+ SK_C_PLUS_PLUS_END_GUARD
+ 
+ #endif

diff --cc include/c/sk_types.h
index e7041a3,1fbbb86..c1caf3a
--- 1/include/c/sk_types.h
--- 2/include/c/sk_types.h
+++ b/include/c/sk_types.h
@@@ -726,7 -661,7 +719,6 @@@ typedef struct 
      int  fBufferMapThreshold;
      bool fUseDrawInsteadOfPartialRenderTargetWrite;
      bool fImmediateMode;
--    bool fClipDrawOpsToBounds;
      int fMaxOpCombineLookback;
      int fMaxOpCombineLookahead;
      bool fUseShaderSwizzling;
@@@ -737,6 -672,6 +729,7 @@@
      bool fDisableGpuYUVConversion;
      bool fSuppressPathRendering;
      gr_contextoptions_gpupathrenderers_t fGpuPathRenderers;
++    bool fAvoidStencilBuffers;
  } gr_context_options_t;
  
  typedef enum {
@@@ -869,13 -813,56 +876,54 @@@ typedef struct sk_svgcanvas_t sk_svgcan
  typedef struct sk_3dview_t sk_3dview_t;
  
  typedef enum {
 -    TRIANGLES_SK_VERTEX_MODE,
 -    TRIANGLE_STRIP_SK_VERTEX_MODE,
 -    TRIANGLE_FAN_SK_VERTEX_MODE,
 -} sk_vertex_mode_t;
 +    TRIANGLES_SK_VERTICES_VERTEX_MODE,
 +    TRIANGLE_STRIP_SK_VERTICES_VERTEX_MODE,
 +    TRIANGLE_FAN_SK_VERTICES_VERTEX_MODE,
 +} sk_vertices_vertex_mode_t;
 +
 +typedef struct sk_vertices_t sk_vertices_t;
  
 -typedef enum {
 -    NON_LINEAR_BLENDING_SK_COLORSPACE_FLAGS = 0x1,
 -} sk_colorspace_flags_t;
 -
+ typedef enum {
+     LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA,
+     SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA,
+ } sk_colorspace_render_target_gamma_t;
+ 
+ typedef enum {
+     SRGB_SK_COLORSPACE_GAMUT,
+     ADOBE_RGB_SK_COLORSPACE_GAMUT,
+     DCIP3_D65_SK_COLORSPACE_GAMUT,
+     REC2020_SK_COLORSPACE_GAMUT,
+ } sk_colorspace_gamut_t;
+ 
+ typedef struct {
+     float fG;
+     float fA;
+     float fB;
+     float fC;
+     float fD;
+     float fE;
+     float fF;
+ } sk_colorspace_transfer_fn_t;
+ 
+ typedef struct {
+     float fRX, fRY;
+     float fGX, fGY;
+     float fBX, fBY;
+     float fWX, fWY;
+ } sk_colorspaceprimaries_t;
+ 
+ typedef enum {
+     NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
+     INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
+     INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,
+ } sk_highcontrastconfig_invertstyle_t;
+ 
+ typedef struct {
+     bool fGrayscale;
+     sk_highcontrastconfig_invertstyle_t fInvertStyle;
+     float fContrast;
+ } sk_highcontrastconfig_t;
+ 
  SK_C_PLUS_PLUS_END_GUARD
  
  #endif

diff --cc src/c/sk_colorspace.cpp
index 0000000,581b591..dc57380
mode 000000,100644..100644
--- /dev/null
--- 2/src/c/sk_colorspace.cpp
+++ b/src/c/sk_colorspace.cpp
@@@ -1,0 -1,64 +1,64 @@@
 -sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50, uint32_t flags) {
 -    return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, AsMatrix44(*toXYZD50), flags).release());
+ /*
+  * Copyright 2017 Xamarin Inc.
+  *
+  * Use of this source code is governed by a BSD-style license that can be
+  * found in the LICENSE file.
+  */
+ 
+ #include "SkColorSpace.h"
+ 
+ #include "sk_colorspace.h"
+ 
+ #include "sk_types_priv.h"
+ 
+ void sk_colorspace_unref(sk_colorspace_t* cColorSpace) {
+     SkSafeUnref(AsColorSpace(cColorSpace));
+ }
+ 
+ sk_colorspace_t* sk_colorspace_new_srgb() {
+     return ToColorSpace(SkColorSpace::MakeSRGB().release());
+ }
+ 
+ sk_colorspace_t* sk_colorspace_new_srgb_linear() {
+     return ToColorSpace(SkColorSpace::MakeSRGBLinear().release());
+ }
+ 
+ sk_colorspace_t* sk_colorspace_new_icc(const void* input, size_t len) {
+     return ToColorSpace(SkColorSpace::MakeICC(input, len).release());
+ }
+ 
 -sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut, uint32_t flags) {
 -    return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, (SkColorSpace::Gamut)gamut, flags).release());
++sk_colorspace_t* sk_colorspace_new_rgb_with_gamma(sk_colorspace_render_target_gamma_t gamma, const sk_matrix44_t* toXYZD50) {
++    return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, AsMatrix44(*toXYZD50)).release());
+ }
+ 
 -sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50, uint32_t flags) {
 -    return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), AsMatrix44(*toXYZD50), flags).release());
++sk_colorspace_t* sk_colorspace_new_rgb_with_gamma_and_gamut(sk_colorspace_render_target_gamma_t gamma, sk_colorspace_gamut_t gamut) {
++    return ToColorSpace(SkColorSpace::MakeRGB((SkColorSpace::RenderTargetGamma)gamma, (SkColorSpace::Gamut)gamut).release());
+ }
+ 
 -sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut, uint32_t flags) {
 -    return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), (SkColorSpace::Gamut)gamut, flags).release());
++sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs(const sk_colorspace_transfer_fn_t* coeffs, const sk_matrix44_t* toXYZD50) {
++    return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), AsMatrix44(*toXYZD50)).release());
+ }
+ 
++sk_colorspace_t* sk_colorspace_new_rgb_with_coeffs_and_gamut(const sk_colorspace_transfer_fn_t* coeffs, sk_colorspace_gamut_t gamut) {
++    return ToColorSpace(SkColorSpace::MakeRGB(AsColorSpaceTransferFn(*coeffs), (SkColorSpace::Gamut)gamut).release());
+ }
+ 
+ bool sk_colorspace_gamma_close_to_srgb(const sk_colorspace_t* cColorSpace) {
+     return AsColorSpace(cColorSpace)->gammaCloseToSRGB();
+ }
+ 
+ bool sk_colorspace_gamma_is_linear(const sk_colorspace_t* cColorSpace) {
+     return AsColorSpace(cColorSpace)->gammaIsLinear();
+ }
+ 
+ bool sk_colorspace_equals(const sk_colorspace_t* src, const sk_colorspace_t* dst) {
+     return SkColorSpace::Equals(AsColorSpace(src), AsColorSpace(dst));
+ }
+ 
+ bool sk_colorspace_to_xyzd50(const sk_colorspace_t* cColorSpace, sk_matrix44_t* toXYZD50) {
+     return AsColorSpace(cColorSpace)->toXYZD50(AsMatrix44(toXYZD50));
+ }
+ 
+ bool sk_colorspaceprimaries_to_xyzd50(const sk_colorspaceprimaries_t* primaries, sk_matrix44_t* toXYZD50) {
+     return AsColorSpacePrimaries(primaries)->toXYZD50(AsMatrix44(toXYZD50));
+ }

diff --cc src/c/sk_enums.cpp
index 6f2e92e,fa52365..40c7c25
--- 1/src/c/sk_enums.cpp
--- 2/src/c/sk_enums.cpp
+++ b/src/c/sk_enums.cpp
@@@ -342,9 -349,18 +349,18 @@@ static_assert ((int)SkVertices::VertexM
  static_assert ((int)SkImage::CachingHint::kAllow_CachingHint      == (int)ALLOW_SK_IMAGE_CACHING_HINT,      ASSERT_MSG(SkImage::CachingHint, sk_image_caching_hint_t));
  static_assert ((int)SkImage::CachingHint::kDisallow_CachingHint   == (int)DISALLOW_SK_IMAGE_CACHING_HINT,   ASSERT_MSG(SkImage::CachingHint, sk_image_caching_hint_t));
  
 -// sk_colorspace_flags_t
 -static_assert ((int)SkColorSpace::ColorSpaceFlags::kNonLinearBlending_ColorSpaceFlag   == (int)NON_LINEAR_BLENDING_SK_COLORSPACE_FLAGS,   ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t));
 -
+ // sk_colorspace_render_target_gamma_t
+ static_assert ((int)SkColorSpace::RenderTargetGamma::kLinear_RenderTargetGamma   == (int)LINEAR_SK_COLORSPACE_RENDER_TARGET_GAMMA,   ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t));
+ static_assert ((int)SkColorSpace::RenderTargetGamma::kSRGB_RenderTargetGamma     == (int)SRGB_SK_COLORSPACE_RENDER_TARGET_GAMMA,     ASSERT_MSG(SkColorSpace::RenderTargetGamma, sk_colorspace_render_target_gamma_t));
+ 
+ // sk_highcontrastconfig_invertstyle_t
+ static_assert ((int)SkHighContrastConfig::InvertStyle::kNoInvert           == (int)NO_INVERT_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,           ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t));
+ static_assert ((int)SkHighContrastConfig::InvertStyle::kInvertBrightness   == (int)INVERT_BRIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,   ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t));
+ static_assert ((int)SkHighContrastConfig::InvertStyle::kInvertLightness    == (int)INVERT_LIGHTNESS_SK_HIGH_CONTRAST_CONFIG_INVERT_STYLE,    ASSERT_MSG(SkHighContrastConfig::InvertStyle, sk_highcontrastconfig_invertstyle_t));
+ 
 +// sk_bitmap_allocflags_t
 +static_assert ((int)SkBitmap::AllocFlags::kZeroPixels_AllocFlag   == (int)ZERO_PIXELS_SK_BITMAP_ALLOC_FLAGS,   ASSERT_MSG(SkBitmap::AllocFlags, sk_bitmap_allocflags_t));
 +
  #if SK_SUPPORT_GPU
  
  // gr_surfaceorigin_t

diff --cc src/c/sk_types_priv.h
index d6a2068,b43a07b..99c2a7b
--- 1/src/c/sk_types_priv.h
--- 2/src/c/sk_types_priv.h
+++ b/src/c/sk_types_priv.h
@@@ -706,22 -796,38 +780,54 @@@ static inline const sk_matrix44_t* ToMa
      return reinterpret_cast<const sk_matrix44_t*>(p);
  }
  
+ static inline const SkHighContrastConfig* AsHighContrastConfig(const sk_highcontrastconfig_t* p) {
+     return reinterpret_cast<const SkHighContrastConfig*>(p);
+ }
+ 
+ static inline const SkHighContrastConfig& AsHighContrastConfig(const sk_highcontrastconfig_t& p) {
+     return reinterpret_cast<const SkHighContrastConfig&>(p);
+ }
+ 
+ static inline SkHighContrastConfig* AsHighContrastConfig(sk_highcontrastconfig_t* p) {
+     return reinterpret_cast<SkHighContrastConfig*>(p);
+ }
+ 
+ static inline SkHighContrastConfig& AsHighContrastConfig(sk_highcontrastconfig_t& p) {
+     return reinterpret_cast<SkHighContrastConfig&>(p);
+ }
+ 
+ static inline sk_highcontrastconfig_t* ToHighContrastConfig(SkHighContrastConfig *p) {
+     return reinterpret_cast<sk_highcontrastconfig_t*>(p);
+ }
+ 
+ static inline sk_highcontrastconfig_t& ToHighContrastConfig(SkHighContrastConfig &p) {
+     return reinterpret_cast<sk_highcontrastconfig_t&>(p);
+ }
+ 
+ static inline const sk_highcontrastconfig_t* ToHighContrastConfig(const SkHighContrastConfig *p) {
+     return reinterpret_cast<const sk_highcontrastconfig_t*>(p);
+ }
+ 
+ static inline const sk_highcontrastconfig_t& ToHighContrastConfig(const SkHighContrastConfig &p) {
+     return reinterpret_cast<const sk_highcontrastconfig_t&>(p);
+ }
+ 
 +static inline const SkVertices* AsVertices(const sk_vertices_t* p) {
 +    return reinterpret_cast<const SkVertices*>(p);
 +}
 +
 +static inline SkVertices* AsVertices(sk_vertices_t* p) {
 +    return reinterpret_cast<SkVertices*>(p);
 +}
 +
 +static inline sk_vertices_t* ToVertices(SkVertices* p) {
 +    return reinterpret_cast<sk_vertices_t*>(p);
 +}
 +
 +static inline const sk_vertices_t* ToVertices(const SkVertices* p) {
 +    return reinterpret_cast<const sk_vertices_t*>(p);
 +}
 +
  static inline void from_c(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
      matrix->setAll(
          cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],