ChangeLog

2020-03-09  Carlos Garcia Campos  <cgarcia@igalia.com>

        [Cairo] Remove PlatformPathCairo

        https://bugs.webkit.org/show_bug.cgi?id=208807

        Reviewed by NOBODY (OOPS!).

        We have a class CairoPath defined in PlatformPathCairo.h that simply wraps a cairo_t. We can use the cairo_t

        directly as PlatformPath and simplify the cairo path implementation.

        * platform/SourcesCairo.txt:

        * platform/graphics/Path.h:

        (WebCore::Path::platformPath const):

        * platform/graphics/cairo/CairoOperations.cpp:

        (WebCore::Cairo::fillRectWithRoundedHole):

        (WebCore::Cairo::fillPath):

        (WebCore::Cairo::strokePath):

        (WebCore::Cairo::clipPath):

        * platform/graphics/cairo/CairoUtilities.cpp:

        (WebCore::appendWebCorePathToCairoContext):

        * platform/graphics/cairo/FontCairo.cpp:

        (WebCore::Font::platformPathForGlyph const):

        * platform/graphics/cairo/PathCairo.cpp:

        (WebCore::Path::Path):

        (WebCore::Path::ensurePlatformPath):

        (WebCore::Path::operator=):

        (WebCore::Path::clear):

        (WebCore::Path::isEmptySlowCase const):

        (WebCore::Path::currentPointSlowCase const):

        (WebCore::Path::translate):

        (WebCore::Path::moveToSlowCase):

        (WebCore::Path::addLineToSlowCase):

        (WebCore::Path::addRect):

        (WebCore::Path::addQuadCurveTo):

        (WebCore::Path::addBezierCurveTo):

        (WebCore::Path::addArcSlowCase):

        (WebCore::Path::addArcTo):

        (WebCore::Path::addEllipse):

        (WebCore::Path::addPath):

        (WebCore::Path::closeSubpath):

        (WebCore::Path::boundingRectSlowCase const):

        (WebCore::Path::strokeBoundingRect const):

        (WebCore::Path::contains const):

        (WebCore::Path::strokeContains const):

        (WebCore::Path::applySlowCase const):

        (WebCore::Path::transform):

        * platform/graphics/cairo/PlatformPathCairo.cpp: Removed.

        * platform/graphics/cairo/PlatformPathCairo.h: Removed.

2020-03-07  Darin Adler  <darin@apple.com>

        Begin moving off of live ranges for WebKit internals

Source/WebCore/platform/SourcesCairo.txt

@@platform/graphics/cairo/NativeImageCairo.cpp

platform/graphics/cairo/PathCairo.cpp

platform/graphics/cairo/PatternCairo.cpp

platform/graphics/cairo/PlatformContextCairo.cpp

43 platform/graphics/cairo/PlatformPathCairo.cpp

4443platform/graphics/cairo/RefPtrCairo.cpp

Source/WebCore/platform/graphics/Path.h

@@class PlatformContextDirect2D;

}

#elif USE(CAIRO)

58#include "RefPtrCairo.h"

5859

namespace WebCore {

class CairoPath;

}

typedef WebCore::CairoPath PlatformPath;

60// cairo_path_fixed_t isn't exposed in Cairo's public API, so we need to use context.

61typedef cairo_t PlatformPath;

#elif USE(WINGDI)

@@typedef PlatformPath* PlatformPathPtr;

using PlatformPathStorageType = RetainPtr<CGMutablePathRef>;

#elif USE(DIRECT2D)

using PlatformPathStorageType = COMPtr<ID2D1GeometryGroup>;

82#elif USE(CAIRO)

83using PlatformPathStorageType = RefPtr<cairo_t>;

#else

using PlatformPathStorageType = PlatformPathPtr;

#endif

@@public:

    PlatformPathPtr platformPath() const { return m_path.get(); }

#elif USE(CG)

    WEBCORE_EXPORT PlatformPathPtr platformPath() const;

192#elif USE(CAIRO)

193 PlatformPathPtr platformPath() const { return m_path.get(); }

#else

    PlatformPathPtr platformPath() const { return m_path; }

#endif

Source/WebCore/platform/graphics/cairo/CairoOperations.cpp

#include "ImageBuffer.h"

#include "Path.h"

#include "PlatformContextCairo.h"

49 #include "PlatformPathCairo.h"

#include "ShadowBlur.h"

#include <algorithm>

#include <cairo.h>

@@void fillRectWithRoundedHole(PlatformContextCairo& platformContext, const FloatR

    cairo_t* cr = platformContext.cr();

    cairo_save(cr);

783 setPathOnCairoContext(platformContext.cr(), path.platformPath()~~->context()~~);

782 setPathOnCairoContext(platformContext.cr(), path.platformPath());

    fillCurrentCairoPath(platformContext, fillSource);

    cairo_restore(cr);

}

@@void fillPath(PlatformContextCairo& platformContext, const Path& path, const Fil

{

    cairo_t* cr = platformContext.cr();

792 setPathOnCairoContext(cr, path.platformPath()~~->context()~~);

791 setPathOnCairoContext(cr, path.platformPath());

    drawPathShadow(platformContext, fillSource, { }, shadowState, Fill);

    fillCurrentCairoPath(platformContext, fillSource);

}

@@void strokePath(PlatformContextCairo& platformContext, const Path& path, const S

{

    cairo_t* cr = platformContext.cr();

815 setPathOnCairoContext(cr, path.platformPath()~~->context()~~);

814 setPathOnCairoContext(cr, path.platformPath());

    drawPathShadow(platformContext, { }, strokeSource, shadowState, Stroke);

    prepareForStroking(cr, strokeSource, PreserveAlpha);

    cairo_stroke(cr);

@@void clipPath(PlatformContextCairo& platformContext, const Path& path, WindRule

    cairo_t* cr = platformContext.cr();

    if (!path.isNull())

1288 setPathOnCairoContext(cr, path.platformPath()~~->context()~~);

1287 setPathOnCairoContext(cr, path.platformPath());

    cairo_fill_rule_t savedFillRule = cairo_get_fill_rule(cr);

    cairo_set_fill_rule(cr, clipRule == WindRule::EvenOdd ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);

Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp

#include "FloatRect.h"

#include "IntRect.h"

#include "Path.h"

38 #include "PlatformPathCairo.h"

#include "RefPtrCairo.h"

#include "Region.h"

#include <wtf/Assertions.h>

@@void appendWebCorePathToCairoContext(cairo_t* context, const Path& path)

{

    if (path.isEmpty())

        return;

112 appendPathToCairoContext(context, path.platformPath()~~->context()~~);

111 appendPathToCairoContext(context, path.platformPath());

}

void appendRegionToCairoContext(cairo_t* to, const cairo_region_t* region)

Source/WebCore/platform/graphics/cairo/FontCairo.cpp

#include "ImageBuffer.h"

#include "Pattern.h"

#include "PlatformContextCairo.h"

46 #include "PlatformPathCairo.h"

#include "ShadowBlur.h"

namespace WebCore {

@@void FontCascade::drawGlyphs(GraphicsContext& context, const Font& font, const G

Path Font::platformPathForGlyph(Glyph glyph) const

{

    Path path;

86 path.ensurePlatformPath();

85 cairo_t* cr = path.ensurePlatformPath();

8786

8887 cairo_glyph_t cairoGlyph = { glyph, 0, 0 };

89 cairo_set_scaled_font(~~path.platformPath()->context()~~, platformData().scaledFont());

90 cairo_glyph_path(~~path.platformPath()->context()~~, &cairoGlyph, 1);

88 cairo_set_scaled_font(cr, platformData().scaledFont());

89 cairo_glyph_path(cr, &cairoGlyph, 1);

    float syntheticBoldOffset = this->syntheticBoldOffset();

    if (syntheticBoldOffset) {

94 cairo_translate(~~path.platformPath()->context()~~, syntheticBoldOffset, 0);

95 cairo_glyph_path(~~path.platformPath()->context()~~, &cairoGlyph, 1);

93 cairo_translate(cr, syntheticBoldOffset, 0);

94 cairo_glyph_path(cr, &cairoGlyph, 1);

    }

    return path;

}

Source/WebCore/platform/graphics/cairo/PathCairo.cpp

                  2005, 2007 Apple Inc. All Rights reserved.

                  2007 Alp Toker <alp@atoker.com>

                  2008 Dirk Schulze <krit@webkit.org>

8 2011 Igalia S.L.

8 2011, 2020 Igalia S.L.

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

#include "CairoUtilities.h"

#include "FloatRect.h"

#include "GraphicsContextImplCairo.h"

34 #include "PlatformPathCairo.h"

#include "StrokeStyleApplier.h"

#include <math.h>

#include <wtf/MathExtras.h>

namespace WebCore {

Path::Path()

    : m_path(0)

{

}

41Path::Path() = default;

4642

Path::~Path()

{

    if (m_path)

        delete m_path;

}

43Path::~Path() = default;

5244

5345Path::Path(const Path& other)

54 : m_path(0)

{

    if (other.isNull())

        return;

59 cairo_t* cr = ensurePlatformPath()~~->context()~~;

60 auto pathCopy = cairo_copy_path(other.platformPath()~~->context()~~);

50 cairo_t* cr = ensurePlatformPath();

51 auto pathCopy = cairo_copy_path(other.platformPath());

    cairo_append_path(cr, pathCopy);

    cairo_path_destroy(pathCopy);

}

Path::Path(Path&& other)

{

    m_path = other.m_path;

@@Path::Path(Path&& other)

PlatformPathPtr Path::ensurePlatformPath()

{

    if (!m_path)

        m_path = new CairoPath();

    return m_path;

    if (!m_path) {

        RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1));

        m_path = adoptRef(cairo_create(surface.get()));

    }

    return m_path.get();

}

Path& Path::operator=(const Path& other)

@@Path& Path::operator=(const Path& other)

        return *this;

    if (other.isNull()) {

        if (m_path) {

            delete m_path;

            m_path = 0;

        }

    } else {

        clear();

        cairo_t* cr = ensurePlatformPath()->context();

        auto pathCopy = cairo_copy_path(other.platformPath()->context());

        cairo_append_path(cr, pathCopy);

        cairo_path_destroy(pathCopy);

77 m_path = nullptr;

78 return *this;

9479 }

9580

    clear();

    cairo_t* cr = ensurePlatformPath();

    auto pathCopy = cairo_copy_path(other.platformPath());

    cairo_append_path(cr, pathCopy);

    cairo_path_destroy(pathCopy);

9687 return *this;

9788}

Path& Path::operator=(Path&& other)

{

    if (this == &other)

        return *this;

103 if (m_path)

104 delete m_path;

    m_path = other.m_path;

    other.m_path = nullptr;

    return *this;

@@void Path::clear()

    if (isNull())

        return;

    cairo_t* cr = platformPath()->context();

    cairo_identity_matrix(cr);

    cairo_new_path(cr);

105 cairo_identity_matrix(m_path.get());

106 cairo_new_path(m_path.get());

}

bool Path::isEmptySlowCase() const

{

122 return !cairo_has_current_point(~~platformP~~ath~~()->cont~~ext());

111 return !cairo_has_current_point(m_path.get());

}

FloatPoint Path::currentPointSlowCase() const

{

116 ASSERT(m_path);

    // FIXME: Is this the correct way?

    double x;

    double y;

130 cairo_get_current_point(~~platformP~~ath~~()->cont~~ext(), &x, &y);

120 cairo_get_current_point(m_path.get(), &x, &y);

    return FloatPoint(x, y);

}

void Path::translate(const FloatSize& p)

{

136 cairo_t* cr = ensurePlatformPath()->context();

137 cairo_translate(cr, -p.width(), -p.height());

126 cairo_translate(ensurePlatformPath(), -p.width(), -p.height());

}

void Path::moveToSlowCase(const FloatPoint& p)

{

142 cairo_t* cr = ensurePlatformPath()->context();

143 cairo_move_to(cr, p.x(), p.y());

131 cairo_move_to(ensurePlatformPath(), p.x(), p.y());

}

void Path::addLineToSlowCase(const FloatPoint& p)

{

148 cairo_t* cr = ensurePlatformPath()->context();

149 cairo_line_to(cr, p.x(), p.y());

136 cairo_line_to(ensurePlatformPath(), p.x(), p.y());

}

void Path::addRect(const FloatRect& rect)

{

154 cairo_t* cr = ensurePlatformPath()->context();

155 cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height());

141 cairo_rectangle(ensurePlatformPath(), rect.x(), rect.y(), rect.width(), rect.height());

156142}

157143

/*

 * inspired by libsvg-cairo

 */

161144void Path::addQuadCurveTo(const FloatPoint& controlPoint, const FloatPoint& point)

162145{

163 cairo_t* cr = ensurePlatformPath()->context();

    double x, y;

    double x1 = controlPoint.x();

    double y1 = controlPoint.y();

    double x2 = point.x();

    double y2 = point.y();

151 cairo_t* cr = ensurePlatformPath();

169152 cairo_get_current_point(cr, &x, &y);

170153 cairo_curve_to(cr,

                   x  + 2.0 / 3.0 * (x1 - x),  y  + 2.0 / 3.0 * (y1 - y),

                   x2 + 2.0 / 3.0 * (x1 - x2), y2 + 2.0 / 3.0 * (y1 - y2),

                   x2, y2);

        x  + 2.0 / 3.0 * (x1 - x),  y  + 2.0 / 3.0 * (y1 - y),

        x2 + 2.0 / 3.0 * (x1 - x2), y2 + 2.0 / 3.0 * (y1 - y2),

        x2, y2);

}

void Path::addBezierCurveTo(const FloatPoint& controlPoint1, const FloatPoint& controlPoint2, const FloatPoint& controlPoint3)

{

    cairo_t* cr = ensurePlatformPath()->context();

    cairo_curve_to(cr, controlPoint1.x(), controlPoint1.y(),

                   controlPoint2.x(), controlPoint2.y(),

                   controlPoint3.x(), controlPoint3.y());

161 cairo_curve_to(ensurePlatformPath(), controlPoint1.x(), controlPoint1.y(),

162 controlPoint2.x(), controlPoint2.y(), controlPoint3.x(), controlPoint3.y());

}

void Path::addArcSlowCase(const FloatPoint& p, float r, float startAngle, float endAngle, bool anticlockwise)

{

186 cairo_t* cr = ensurePlatformPath()~~->context()~~;

167 cairo_t* cr = ensurePlatformPath();

    float sweep = endAngle - startAngle;

    const float twoPI = 2 * piFloat;

    if ((sweep <= -twoPI || sweep >= twoPI)

@@void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)

    if (isEmpty())

        return;

216 cairo_t* cr = platformPath()->context();

217

197 cairo_t* cr = platformPath();

    double x0, y0;

    cairo_get_current_point(cr, &x0, &y0);

    FloatPoint p0(x0, y0);

@@void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)

    FloatPoint p1p2((p2.x() - p1.x()),(p2.y() - p1.y()));

    float p1p0_length = std::hypot(p1p0.x(), p1p0.y());

    float p1p2_length = std::hypot(p1p2.x(), p1p2.y());

234

    double cos_phi = (p1p0.x() * p1p2.x() + p1p0.y() * p1p2.y()) / (p1p0_length * p1p2_length);

    // all points on a line logic

    if (cos_phi == -1) {

@@void Path::addArcTo(const FloatPoint& p1, const FloatPoint& p2, float radius)

void Path::addEllipse(FloatPoint point, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise)

{

293 cairo_t* cr = ensurePlatformPath()~~->context()~~;

272 cairo_t* cr = ensurePlatformPath();

    cairo_save(cr);

    cairo_translate(cr, point.x(), point.y());

    cairo_rotate(cr, rotation);

@@void Path::addEllipse(FloatPoint point, float radiusX, float radiusY, float rota

void Path::addEllipse(const FloatRect& rect)

{

309 cairo_t* cr = ensurePlatformPath()~~->context()~~;

288 cairo_t* cr = ensurePlatformPath();

    cairo_save(cr);

    float yRadius = .5 * rect.height();

    float xRadius = .5 * rect.width();

@@void Path::addPath(const Path& path, const AffineTransform& transform)

    if (cairo_matrix_invert(&matrix) != CAIRO_STATUS_SUCCESS)

        return;

328 cairo_t* cr = path.platformPath()~~->context()~~;

307 cairo_t* cr = path.platformPath();

    cairo_save(cr);

    cairo_transform(cr, &matrix);

    auto pathCopy = cairo_copy_path(cr);

    cairo_restore(cr);

333 cairo_append_path(ensurePlatformPath()~~->context()~~, pathCopy);

312 cairo_append_path(ensurePlatformPath(), pathCopy);

    cairo_path_destroy(pathCopy);

}

void Path::closeSubpath()

{

339 cairo_t* cr = ensurePlatformPath()->context();

340 cairo_close_path(cr);

318 cairo_close_path(ensurePlatformPath());

}

FloatRect Path::boundingRectSlowCase() const

{

345 ~~cairo_t* cr =~~ ~~platformP~~ath~~()->context(~~);

323 ASSERT(m_path);

346324 double x0, x1, y0, y1;

347 cairo_path_extents(cr, &x0, &y0, &x1, &y1);

325 cairo_path_extents(m_path.get(), &x0, &y0, &x1, &y1);

    return FloatRect(x0, y0, x1 - x0, y1 - y0);

}

@@FloatRect Path::strokeBoundingRect(StrokeStyleApplier* applier) const

    if (isNull())

        return FloatRect();

357 ~~cairo_t* cr =~~ ~~platformP~~ath~~()->context(~~);

335 ASSERT(m_path);

358336 if (applier) {

359 GraphicsContext gc(GraphicsContextImplCairo::createFactory(cr));

337 GraphicsContext gc(GraphicsContextImplCairo::createFactory(m_path.get()));

        applier->strokeStyle(&gc);

    }

    double x0, x1, y0, y1;

364 cairo_stroke_extents(cr, &x0, &y0, &x1, &y1);

342 cairo_stroke_extents(m_path.get(), &x0, &y0, &x1, &y1);

    return FloatRect(x0, y0, x1 - x0, y1 - y0);

}

@@bool Path::contains(const FloatPoint& point, WindRule rule) const

{

    if (isNull() || !std::isfinite(point.x()) || !std::isfinite(point.y()))

        return false;

    cairo_t* cr = platformPath()->context();

    cairo_fill_rule_t cur = cairo_get_fill_rule(cr);

    cairo_set_fill_rule(cr, rule == WindRule::EvenOdd ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);

    bool contains = cairo_in_fill(cr, point.x(), point.y());

    cairo_set_fill_rule(cr, cur);

    ASSERT(m_path);

    cairo_fill_rule_t cur = cairo_get_fill_rule(m_path.get());

    cairo_set_fill_rule(m_path.get(), rule == WindRule::EvenOdd ? CAIRO_FILL_RULE_EVEN_ODD : CAIRO_FILL_RULE_WINDING);

    bool contains = cairo_in_fill(m_path.get(), point.x(), point.y());

    cairo_set_fill_rule(m_path.get(), cur);

    return contains;

}

@@bool Path::strokeContains(StrokeStyleApplier& applier, const FloatPoint& point)

    if (isNull())

        return false;

385 ~~cairo_t* cr =~~ ~~platformP~~ath~~()->context(~~);

364 ASSERT(m_path);

386365 {

387 GraphicsContext graphicsContext(GraphicsContextImplCairo::createFactory(cr));

366 GraphicsContext graphicsContext(GraphicsContextImplCairo::createFactory(m_path.get()));

        applier.strokeStyle(&graphicsContext);

    }

391 return cairo_in_stroke(cr, point.x(), point.y());

370 return cairo_in_stroke(m_path.get(), point.x(), point.y());

}

void Path::applySlowCase(const PathApplierFunction& function) const

{

396 ~~cairo_t* cr =~~ ~~platformP~~ath~~()->context(~~);

397 auto pathCopy = cairo_copy_path(cr);

375 ASSERT(m_path);

376 auto pathCopy = cairo_copy_path(m_path.get());

    cairo_path_data_t* data;

    PathElement pathElement;

@@FloatRect Path::fastBoundingRectSlowCase() const

void Path::transform(const AffineTransform& transform)

{

437 cairo_t* cr = ensurePlatformPath()->context();

438416 cairo_matrix_t matrix = toCairoMatrix(transform);

439417 cairo_matrix_invert(&matrix);

440 cairo_transform(cr, &matrix);

418 cairo_transform(ensurePlatformPath(), &matrix);

}

bool Path::isNull() const

Source/WebCore/platform/graphics/cairo/PlatformPathCairo.cpp

/*

 * Copyright (C) 2011 Collabora Ltd.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "config.h"

#include "PlatformPathCairo.h"

#if USE(CAIRO)

#include <cairo.h>

namespace WebCore {

CairoPath::CairoPath()

{

    // cairo_t takes its own reference of the surface, meaning we don't have to keep one.

    auto surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1));

    m_context = adoptRef(cairo_create(surface.get()));

}

} // namespace WebCore

#endif // USE(CAIRO)

Source/WebCore/platform/graphics/cairo/PlatformPathCairo.h

/*

 *  Copyright (C) 2007 Alp Toker <alp.toker@collabora.co.uk>

 *  Copyright (C) 2010 Igalia S.L.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#pragma once

#if USE(CAIRO)

#include "RefPtrCairo.h"

namespace WebCore {

// This is necessary since cairo_path_fixed_t isn't exposed in Cairo's public API.

class CairoPath {

public:

    CairoPath();

    ~CairoPath() = default;

    cairo_t* context() { return m_context.get(); }

private:

    RefPtr<cairo_t> m_context;

};

} // namespace WebCore

#endif // USE(CAIRO)