Replace agg with skia

core/src/fxge/agg/agg23/agg_pixfmt_gray.h

Index: core/src/fxge/agg/agg23/agg_pixfmt_gray.h
diff --git a/core/src/fxge/agg/agg23/agg_pixfmt_gray.h b/core/src/fxge/agg/agg23/agg_pixfmt_gray.h
deleted file mode 100644
index 052a2e35d86eaac7d70bfb80eedca8477662592a..0000000000000000000000000000000000000000
--- a/core/src/fxge/agg/agg23/agg_pixfmt_gray.h
+++ /dev/null
@@ -1,177 +0,0 @@
-
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.3
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//----------------------------------------------------------------------------
-//
-// Adaptation for high precision colors has been sponsored by
-// Liberty Technology Systems, Inc., visit http://lib-sys.com
-//
-// Liberty Technology Systems, Inc. is the provider of
-// PostScript and PDF technology for software developers.
-//
-//----------------------------------------------------------------------------
-#ifndef AGG_PIXFMT_GRAY_INCLUDED
-#define AGG_PIXFMT_GRAY_INCLUDED
-#include "agg_basics.h"
-#include "agg_color_gray.h"
-#include "agg_rendering_buffer.h"
-namespace agg
-{
-template<class ColorT> struct blender_gray : public CFX_Object {
-    typedef ColorT color_type;
-    typedef typename color_type::value_type value_type;
-    typedef typename color_type::calc_type calc_type;
-    enum base_scale_e { base_shift = color_type::base_shift };
-    static AGG_INLINE void blend_pix(value_type* p, unsigned cv,
-                                     unsigned alpha, unsigned cover = 0)
-    {
-        *p = (value_type)((((cv - calc_type(*p)) * alpha) + (calc_type(*p) << base_shift)) >> base_shift);
-    }
-};
-template<class Blender, unsigned Step = 1, unsigned Offset = 0>
-class pixel_formats_gray : public CFX_Object
-{
-public:
-    typedef rendering_buffer::row_data row_data;
-    typedef rendering_buffer::span_data span_data;
-    typedef typename Blender::color_type color_type;
-    typedef typename color_type::value_type value_type;
-    typedef typename color_type::calc_type calc_type;
-    enum base_scale_e {
-        base_shift = color_type::base_shift,
-        base_size  = color_type::base_size,
-        base_mask  = color_type::base_mask
-    };
-private:
-    static AGG_INLINE void copy_or_blend_pix(value_type* p,
-            const color_type& c,
-            unsigned cover)
-    {
-        if (c.a) {
-            calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-            if(alpha == base_mask) {
-                *p = c.v;
-            } else {
-                Blender::blend_pix(p, c.v, alpha, cover);
-            }
-        }
-    }
-    static AGG_INLINE void copy_or_blend_pix(value_type* p,
-            const color_type& c)
-    {
-        if (c.a) {
-            if(c.a == base_mask) {
-                *p = c.v;
-            } else {
-                Blender::blend_pix(p, c.v, c.a);
-            }
-        }
-    }
-public:
-    pixel_formats_gray(rendering_buffer& rb) :
-        m_rbuf(&rb)
-    {}
-    AGG_INLINE unsigned width()  const
-    {
-        return m_rbuf->width();
-    }
-    AGG_INLINE unsigned height() const
-    {
-        return m_rbuf->height();
-    }
-    AGG_INLINE color_type pixel(int x, int y) const
-    {
-        value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
-        return color_type(*p);
-    }
-    row_data row(int x, int y) const
-    {
-        return row_data(x,
-                        width() - 1,
-                        m_rbuf->row(y) +
-                        x * Step * sizeof(value_type) +
-                        Offset * sizeof(value_type));
-    }
-    span_data span(int x, int y, unsigned len)
-    {
-        return span_data(x, len,
-                         m_rbuf->row(y) +
-                         x * Step * sizeof(value_type) +
-                         Offset * sizeof(value_type));
-    }
-    AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
-    {
-        *((value_type*)m_rbuf->row(y) + x * Step + Offset) = c.v;
-    }
-    AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
-    {
-        copy_or_blend_pix((value_type*)m_rbuf->row(y) + x * Step + Offset, c, cover);
-    }
-    AGG_INLINE void copy_hline(int x, int y,
-                               unsigned len,
-                               const color_type& c)
-    {
-        value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
-        do {
-            *p = c.v;
-            p += Step;
-        } while(--len);
-    }
-    void blend_hline(int x, int y,
-                     unsigned len,
-                     const color_type& c,
-                     int8u cover)
-    {
-        if (c.a) {
-            value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
-            calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8;
-            if(alpha == base_mask) {
-                do {
-                    *p = c.v;
-                    p += Step;
-                } while(--len);
-            } else {
-                do {
-                    Blender::blend_pix(p, c.v, alpha, cover);
-                    p += Step;
-                } while(--len);
-            }
-        }
-    }
-    void blend_solid_hspan(int x, int y,
-                           unsigned len,
-                           const color_type& c,
-                           const int8u* covers)
-    {
-        if (c.a) {
-            value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset;
-            do {
-                calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
-                if(alpha == base_mask) {
-                    *p = c.v;
-                } else {
-                    Blender::blend_pix(p, c.v, alpha, *covers);
-                }
-                p += Step;
-                ++covers;
-            } while(--len);
-        }
-    }
-private:
-    rendering_buffer* m_rbuf;
-};
-typedef blender_gray<gray8>      blender_gray8;
-typedef pixel_formats_gray<blender_gray8, 1, 0> pixfmt_gray8;
-}
-#endif