Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

   1 /*
   2  * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
   4  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
   5  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
   6  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
   7  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
   8  * Copyright (C) 2012 Intel Corporation. All rights reserved.
   9  * Copyright (C) 2013, 2014 Adobe Systems Incorporated. All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  28  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "config.h"
  34 #include "CanvasRenderingContext2D.h"
  35
  36 #include "BitmapImage.h"
  37 #include "CSSFontSelector.h"
  38 #include "CSSParser.h"
  39 #include "CSSPropertyNames.h"
  40 #include "CachedImage.h"
  41 #include "CanvasGradient.h"
  42 #include "CanvasPattern.h"
  43 #include "DOMMatrix.h"
  44 #include "DOMMatrixInit.h"
  45 #include "DOMPath.h"
  46 #include "DisplayListRecorder.h"
  47 #include "DisplayListReplayer.h"
  48 #include "FloatQuad.h"
  49 #include "HTMLImageElement.h"
  50 #include "HTMLVideoElement.h"
  51 #include "ImageBuffer.h"
  52 #include "ImageData.h"
  53 #include "RenderElement.h"
  54 #include "RenderImage.h"
  55 #include "RenderLayer.h"
  56 #include "RenderTheme.h"
  57 #include "SecurityOrigin.h"
  58 #include "StrokeStyleApplier.h"
  59 #include "StyleProperties.h"
  60 #include "StyleResolver.h"
  61 #include "TextMetrics.h"
  62 #include "TextRun.h"
  63 #include "TextStream.h"
  64 #include <wtf/CheckedArithmetic.h>
  65 #include <wtf/MathExtras.h>
  66 #include <wtf/NeverDestroyed.h>
  67 #include <wtf/text/StringBuilder.h>
  68
  69 #if USE(CG) && !PLATFORM(IOS)
  70 #include <ApplicationServices/ApplicationServices.h>
  71 #endif
  72
  73 namespace WebCore {
  74
  75 using namespace HTMLNames;
  76
  77 #if USE(CG)
  78 const CanvasRenderingContext2D::ImageSmoothingQuality defaultSmoothingQuality = CanvasRenderingContext2D::ImageSmoothingQuality::Low;
  79 #else
  80 const CanvasRenderingContext2D::ImageSmoothingQuality defaultSmoothingQuality = CanvasRenderingContext2D::ImageSmoothingQuality::Medium;
  81 #endif
  82
  83 static const int defaultFontSize = 10;
  84 static const char* const defaultFontFamily = "sans-serif";
  85 static const char* const defaultFont = "10px sans-serif";
  86
  87 struct DisplayListDrawingContext {
  88     WTF_MAKE_FAST_ALLOCATED;
  89 public:
  90     GraphicsContext context;
  91     DisplayList::Recorder recorder;
  92     DisplayList::DisplayList displayList;
  93
  94     DisplayListDrawingContext(const FloatRect& clip)
  95         : recorder(context, displayList, clip, AffineTransform())
  96     {
  97     }
  98 };
  99
 100 typedef HashMap<const CanvasRenderingContext2D*, std::unique_ptr<DisplayList::DisplayList>> ContextDisplayListHashMap;
 101
 102 static ContextDisplayListHashMap& contextDisplayListMap()
 103 {
 104     static NeverDestroyed<ContextDisplayListHashMap> sharedHashMap;
 105     return sharedHashMap;
 106 }
 107
 108 class CanvasStrokeStyleApplier : public StrokeStyleApplier {
 109 public:
 110     CanvasStrokeStyleApplier(CanvasRenderingContext2D* canvasContext)
 111         : m_canvasContext(canvasContext)
 112     {
 113     }
 114
 115     void strokeStyle(GraphicsContext* c) override
 116     {
 117         c->setStrokeThickness(m_canvasContext->lineWidth());
 118         c->setLineCap(m_canvasContext->getLineCap());
 119         c->setLineJoin(m_canvasContext->getLineJoin());
 120         c->setMiterLimit(m_canvasContext->miterLimit());
 121         const Vector<float>& lineDash = m_canvasContext->getLineDash();
 122         DashArray convertedLineDash(lineDash.size());
 123         for (size_t i = 0; i < lineDash.size(); ++i)
 124             convertedLineDash[i] = static_cast<DashArrayElement>(lineDash[i]);
 125         c->setLineDash(convertedLineDash, m_canvasContext->lineDashOffset());
 126     }
 127
 128 private:
 129     CanvasRenderingContext2D* m_canvasContext;
 130 };
 131
 132 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
 133     : CanvasRenderingContext(canvas)
 134     , m_stateStack(1)
 135     , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
 136 #if ENABLE(DASHBOARD_SUPPORT)
 137     , m_usesDashboardCompatibilityMode(usesDashboardCompatibilityMode)
 138 #endif
 139 {
 140 #if !ENABLE(DASHBOARD_SUPPORT)
 141     ASSERT_UNUSED(usesDashboardCompatibilityMode, !usesDashboardCompatibilityMode);
 142 #endif
 143 }
 144
 145 void CanvasRenderingContext2D::unwindStateStack()
 146 {
 147     // Ensure that the state stack in the ImageBuffer's context
 148     // is cleared before destruction, to avoid assertions in the
 149     // GraphicsContext dtor.
 150     if (size_t stackSize = m_stateStack.size()) {
 151         if (GraphicsContext* context = canvas().existingDrawingContext()) {
 152             while (--stackSize)
 153                 context->restore();
 154         }
 155     }
 156 }
 157
 158 CanvasRenderingContext2D::~CanvasRenderingContext2D()
 159 {
 160 #if !ASSERT_DISABLED
 161     unwindStateStack();
 162 #endif
 163
 164     if (UNLIKELY(tracksDisplayListReplay()))
 165         contextDisplayListMap().remove(this);
 166 }
 167
 168 bool CanvasRenderingContext2D::isAccelerated() const
 169 {
 170 #if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
 171     if (!canvas().hasCreatedImageBuffer())
 172         return false;
 173     auto* context = drawingContext();
 174     return context && context->isAcceleratedContext();
 175 #else
 176     return false;
 177 #endif
 178 }
 179
 180 void CanvasRenderingContext2D::reset()
 181 {
 182     unwindStateStack();
 183     m_stateStack.resize(1);
 184     m_stateStack.first() = State();
 185     m_path.clear();
 186     m_unrealizedSaveCount = 0;
 187
 188     m_recordingContext = nullptr;
 189 }
 190
 191 CanvasRenderingContext2D::State::State()
 192     : strokeStyle(Color::black)
 193     , fillStyle(Color::black)
 194     , lineWidth(1)
 195     , lineCap(ButtCap)
 196     , lineJoin(MiterJoin)
 197     , miterLimit(10)
 198     , shadowBlur(0)
 199     , shadowColor(Color::transparent)
 200     , globalAlpha(1)
 201     , globalComposite(CompositeSourceOver)
 202     , globalBlend(BlendModeNormal)
 203     , hasInvertibleTransform(true)
 204     , lineDashOffset(0)
 205     , imageSmoothingEnabled(true)
 206     , imageSmoothingQuality(defaultSmoothingQuality)
 207     , textAlign(StartTextAlign)
 208     , textBaseline(AlphabeticTextBaseline)
 209     , direction(Direction::Inherit)
 210     , unparsedFont(defaultFont)
 211 {
 212 }
 213
 214 CanvasRenderingContext2D::State::State(const State& other)
 215     : unparsedStrokeColor(other.unparsedStrokeColor)
 216     , unparsedFillColor(other.unparsedFillColor)
 217     , strokeStyle(other.strokeStyle)
 218     , fillStyle(other.fillStyle)
 219     , lineWidth(other.lineWidth)
 220     , lineCap(other.lineCap)
 221     , lineJoin(other.lineJoin)
 222     , miterLimit(other.miterLimit)
 223     , shadowOffset(other.shadowOffset)
 224     , shadowBlur(other.shadowBlur)
 225     , shadowColor(other.shadowColor)
 226     , globalAlpha(other.globalAlpha)
 227     , globalComposite(other.globalComposite)
 228     , globalBlend(other.globalBlend)
 229     , transform(other.transform)
 230     , hasInvertibleTransform(other.hasInvertibleTransform)
 231     , lineDashOffset(other.lineDashOffset)
 232     , imageSmoothingEnabled(other.imageSmoothingEnabled)
 233     , imageSmoothingQuality(other.imageSmoothingQuality)
 234     , textAlign(other.textAlign)
 235     , textBaseline(other.textBaseline)
 236     , direction(other.direction)
 237     , unparsedFont(other.unparsedFont)
 238     , font(other.font)
 239 {
 240 }
 241
 242 CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other)
 243 {
 244     if (this == &other)
 245         return *this;
 246
 247     unparsedStrokeColor = other.unparsedStrokeColor;
 248     unparsedFillColor = other.unparsedFillColor;
 249     strokeStyle = other.strokeStyle;
 250     fillStyle = other.fillStyle;
 251     lineWidth = other.lineWidth;
 252     lineCap = other.lineCap;
 253     lineJoin = other.lineJoin;
 254     miterLimit = other.miterLimit;
 255     shadowOffset = other.shadowOffset;
 256     shadowBlur = other.shadowBlur;
 257     shadowColor = other.shadowColor;
 258     globalAlpha = other.globalAlpha;
 259     globalComposite = other.globalComposite;
 260     globalBlend = other.globalBlend;
 261     transform = other.transform;
 262     hasInvertibleTransform = other.hasInvertibleTransform;
 263     imageSmoothingEnabled = other.imageSmoothingEnabled;
 264     imageSmoothingQuality = other.imageSmoothingQuality;
 265     textAlign = other.textAlign;
 266     textBaseline = other.textBaseline;
 267     direction = other.direction;
 268     unparsedFont = other.unparsedFont;
 269     font = other.font;
 270
 271     return *this;
 272 }
 273
 274 CanvasRenderingContext2D::FontProxy::~FontProxy()
 275 {
 276     if (realized())
 277         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
 278 }
 279
 280 CanvasRenderingContext2D::FontProxy::FontProxy(const FontProxy& other)
 281     : m_font(other.m_font)
 282 {
 283     if (realized())
 284         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
 285 }
 286
 287 auto CanvasRenderingContext2D::FontProxy::operator=(const FontProxy& other) -> FontProxy&
 288 {
 289     if (realized())
 290         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
 291
 292     m_font = other.m_font;
 293
 294     if (realized())
 295         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
 296
 297     return *this;
 298 }
 299
 300 inline void CanvasRenderingContext2D::FontProxy::update(FontSelector& selector)
 301 {
 302     ASSERT(&selector == m_font.fontSelector()); // This is an invariant. We should only ever be registered for callbacks on m_font.m_fonts.m_fontSelector.
 303     if (realized())
 304         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
 305     m_font.update(&selector);
 306     if (realized())
 307         m_font.fontSelector()->registerForInvalidationCallbacks(*this);
 308     ASSERT(&selector == m_font.fontSelector());
 309 }
 310
 311 void CanvasRenderingContext2D::FontProxy::fontsNeedUpdate(FontSelector& selector)
 312 {
 313     ASSERT_ARG(selector, &selector == m_font.fontSelector());
 314     ASSERT(realized());
 315
 316     update(selector);
 317 }
 318
 319 inline void CanvasRenderingContext2D::FontProxy::initialize(FontSelector& fontSelector, const RenderStyle& newStyle)
 320 {
 321     // Beware! m_font.fontSelector() might not point to document.fontSelector()!
 322     ASSERT(newStyle.fontCascade().fontSelector() == &fontSelector);
 323     if (realized())
 324         m_font.fontSelector()->unregisterForInvalidationCallbacks(*this);
 325     m_font = newStyle.fontCascade();
 326     m_font.update(&fontSelector);
 327     ASSERT(&fontSelector == m_font.fontSelector());
 328     m_font.fontSelector()->registerForInvalidationCallbacks(*this);
 329 }
 330
 331 inline FontMetrics CanvasRenderingContext2D::FontProxy::fontMetrics() const
 332 {
 333     return m_font.fontMetrics();
 334 }
 335
 336 inline const FontCascadeDescription& CanvasRenderingContext2D::FontProxy::fontDescription() const
 337 {
 338     return m_font.fontDescription();
 339 }
 340
 341 inline float CanvasRenderingContext2D::FontProxy::width(const TextRun& textRun) const
 342 {
 343     return m_font.width(textRun);
 344 }
 345
 346 inline void CanvasRenderingContext2D::FontProxy::drawBidiText(GraphicsContext& context, const TextRun& run, const FloatPoint& point, FontCascade::CustomFontNotReadyAction action) const
 347 {
 348     context.drawBidiText(m_font, run, point, action);
 349 }
 350
 351 void CanvasRenderingContext2D::realizeSaves()
 352 {
 353     if (m_unrealizedSaveCount)
 354         realizeSavesLoop();
 355
 356     if (m_unrealizedSaveCount) {
 357         static NeverDestroyed<String> consoleMessage(MAKE_STATIC_STRING_IMPL("CanvasRenderingContext2D.save() has been called without a matching restore() too many times. Ignoring save()."));
 358         canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage);
 359     }
 360 }
 361
 362 void CanvasRenderingContext2D::realizeSavesLoop()
 363 {
 364     ASSERT(m_unrealizedSaveCount);
 365     ASSERT(m_stateStack.size() >= 1);
 366     GraphicsContext* context = drawingContext();
 367     do {
 368         if (m_stateStack.size() > MaxSaveCount)
 369             break;
 370         m_stateStack.append(state());
 371         if (context)
 372             context->save();
 373     } while (--m_unrealizedSaveCount);
 374 }
 375
 376 void CanvasRenderingContext2D::restore()
 377 {
 378     if (m_unrealizedSaveCount) {
 379         --m_unrealizedSaveCount;
 380         return;
 381     }
 382     ASSERT(m_stateStack.size() >= 1);
 383     if (m_stateStack.size() <= 1)
 384         return;
 385     m_path.transform(state().transform);
 386     m_stateStack.removeLast();
 387     if (std::optional<AffineTransform> inverse = state().transform.inverse())
 388         m_path.transform(inverse.value());
 389     GraphicsContext* c = drawingContext();
 390     if (!c)
 391         return;
 392     c->restore();
 393 }
 394
 395 void CanvasRenderingContext2D::setStrokeStyle(CanvasStyle style)
 396 {
 397     if (!style.isValid())
 398         return;
 399
 400     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentColor(style))
 401         return;
 402
 403     if (style.isCurrentColor()) {
 404         if (style.hasOverrideAlpha()) {
 405             // FIXME: Should not use RGBA32 here.
 406             style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
 407         } else
 408             style = CanvasStyle(currentColor(&canvas()));
 409     } else
 410         checkOrigin(style.canvasPattern());
 411
 412     realizeSaves();
 413     State& state = modifiableState();
 414     state.strokeStyle = style;
 415     GraphicsContext* c = drawingContext();
 416     if (!c)
 417         return;
 418     state.strokeStyle.applyStrokeColor(*c);
 419     state.unparsedStrokeColor = String();
 420 }
 421
 422 void CanvasRenderingContext2D::setFillStyle(CanvasStyle style)
 423 {
 424     if (!style.isValid())
 425         return;
 426
 427     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentColor(style))
 428         return;
 429
 430     if (style.isCurrentColor()) {
 431         if (style.hasOverrideAlpha()) {
 432             // FIXME: Should not use RGBA32 here.
 433             style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
 434         } else
 435             style = CanvasStyle(currentColor(&canvas()));
 436     } else
 437         checkOrigin(style.canvasPattern());
 438
 439     realizeSaves();
 440     State& state = modifiableState();
 441     state.fillStyle = style;
 442     GraphicsContext* c = drawingContext();
 443     if (!c)
 444         return;
 445     state.fillStyle.applyFillColor(*c);
 446     state.unparsedFillColor = String();
 447 }
 448
 449 float CanvasRenderingContext2D::lineWidth() const
 450 {
 451     return state().lineWidth;
 452 }
 453
 454 void CanvasRenderingContext2D::setLineWidth(float width)
 455 {
 456     if (!(std::isfinite(width) && width > 0))
 457         return;
 458     if (state().lineWidth == width)
 459         return;
 460     realizeSaves();
 461     modifiableState().lineWidth = width;
 462     GraphicsContext* c = drawingContext();
 463     if (!c)
 464         return;
 465     c->setStrokeThickness(width);
 466 }
 467
 468 String CanvasRenderingContext2D::lineCap() const
 469 {
 470     return lineCapName(state().lineCap);
 471 }
 472
 473 void CanvasRenderingContext2D::setLineCap(const String& s)
 474 {
 475     LineCap cap;
 476     if (!parseLineCap(s, cap))
 477         return;
 478     if (state().lineCap == cap)
 479         return;
 480     realizeSaves();
 481     modifiableState().lineCap = cap;
 482     GraphicsContext* c = drawingContext();
 483     if (!c)
 484         return;
 485     c->setLineCap(cap);
 486 }
 487
 488 String CanvasRenderingContext2D::lineJoin() const
 489 {
 490     return lineJoinName(state().lineJoin);
 491 }
 492
 493 void CanvasRenderingContext2D::setLineJoin(const String& s)
 494 {
 495     LineJoin join;
 496     if (!parseLineJoin(s, join))
 497         return;
 498     if (state().lineJoin == join)
 499         return;
 500     realizeSaves();
 501     modifiableState().lineJoin = join;
 502     GraphicsContext* c = drawingContext();
 503     if (!c)
 504         return;
 505     c->setLineJoin(join);
 506 }
 507
 508 float CanvasRenderingContext2D::miterLimit() const
 509 {
 510     return state().miterLimit;
 511 }
 512
 513 void CanvasRenderingContext2D::setMiterLimit(float limit)
 514 {
 515     if (!(std::isfinite(limit) && limit > 0))
 516         return;
 517     if (state().miterLimit == limit)
 518         return;
 519     realizeSaves();
 520     modifiableState().miterLimit = limit;
 521     GraphicsContext* c = drawingContext();
 522     if (!c)
 523         return;
 524     c->setMiterLimit(limit);
 525 }
 526
 527 float CanvasRenderingContext2D::shadowOffsetX() const
 528 {
 529     return state().shadowOffset.width();
 530 }
 531
 532 void CanvasRenderingContext2D::setShadowOffsetX(float x)
 533 {
 534     if (!std::isfinite(x))
 535         return;
 536     if (state().shadowOffset.width() == x)
 537         return;
 538     realizeSaves();
 539     modifiableState().shadowOffset.setWidth(x);
 540     applyShadow();
 541 }
 542
 543 float CanvasRenderingContext2D::shadowOffsetY() const
 544 {
 545     return state().shadowOffset.height();
 546 }
 547
 548 void CanvasRenderingContext2D::setShadowOffsetY(float y)
 549 {
 550     if (!std::isfinite(y))
 551         return;
 552     if (state().shadowOffset.height() == y)
 553         return;
 554     realizeSaves();
 555     modifiableState().shadowOffset.setHeight(y);
 556     applyShadow();
 557 }
 558
 559 float CanvasRenderingContext2D::shadowBlur() const
 560 {
 561     return state().shadowBlur;
 562 }
 563
 564 void CanvasRenderingContext2D::setShadowBlur(float blur)
 565 {
 566     if (!(std::isfinite(blur) && blur >= 0))
 567         return;
 568     if (state().shadowBlur == blur)
 569         return;
 570     realizeSaves();
 571     modifiableState().shadowBlur = blur;
 572     applyShadow();
 573 }
 574
 575 String CanvasRenderingContext2D::shadowColor() const
 576 {
 577     return Color(state().shadowColor).serialized();
 578 }
 579
 580 void CanvasRenderingContext2D::setShadowColor(const String& colorString)
 581 {
 582     Color color = parseColorOrCurrentColor(colorString, &canvas());
 583     if (!color.isValid())
 584         return;
 585     if (state().shadowColor == color)
 586         return;
 587     realizeSaves();
 588     modifiableState().shadowColor = color;
 589     applyShadow();
 590 }
 591
 592 const Vector<float>& CanvasRenderingContext2D::getLineDash() const
 593 {
 594     return state().lineDash;
 595 }
 596
 597 static bool lineDashSequenceIsValid(const Vector<float>& dash)
 598 {
 599     for (size_t i = 0; i < dash.size(); i++) {
 600         if (!std::isfinite(dash[i]) || dash[i] < 0)
 601             return false;
 602     }
 603     return true;
 604 }
 605
 606 void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)
 607 {
 608     if (!lineDashSequenceIsValid(dash))
 609         return;
 610
 611     realizeSaves();
 612     modifiableState().lineDash = dash;
 613     // Spec requires the concatenation of two copies the dash list when the
 614     // number of elements is odd
 615     if (dash.size() % 2)
 616         modifiableState().lineDash.appendVector(dash);
 617
 618     applyLineDash();
 619 }
 620
 621 void CanvasRenderingContext2D::setWebkitLineDash(const Vector<float>& dash)
 622 {
 623     if (!lineDashSequenceIsValid(dash))
 624         return;
 625
 626     realizeSaves();
 627     modifiableState().lineDash = dash;
 628
 629     applyLineDash();
 630 }
 631
 632 float CanvasRenderingContext2D::lineDashOffset() const
 633 {
 634     return state().lineDashOffset;
 635 }
 636
 637 void CanvasRenderingContext2D::setLineDashOffset(float offset)
 638 {
 639     if (!std::isfinite(offset) || state().lineDashOffset == offset)
 640         return;
 641
 642     realizeSaves();
 643     modifiableState().lineDashOffset = offset;
 644     applyLineDash();
 645 }
 646
 647 void CanvasRenderingContext2D::applyLineDash() const
 648 {
 649     GraphicsContext* c = drawingContext();
 650     if (!c)
 651         return;
 652     DashArray convertedLineDash(state().lineDash.size());
 653     for (size_t i = 0; i < state().lineDash.size(); ++i)
 654         convertedLineDash[i] = static_cast<DashArrayElement>(state().lineDash[i]);
 655     c->setLineDash(convertedLineDash, state().lineDashOffset);
 656 }
 657
 658 float CanvasRenderingContext2D::globalAlpha() const
 659 {
 660     return state().globalAlpha;
 661 }
 662
 663 void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
 664 {
 665     if (!(alpha >= 0 && alpha <= 1))
 666         return;
 667     if (state().globalAlpha == alpha)
 668         return;
 669     realizeSaves();
 670     modifiableState().globalAlpha = alpha;
 671     GraphicsContext* c = drawingContext();
 672     if (!c)
 673         return;
 674     c->setAlpha(alpha);
 675 }
 676
 677 String CanvasRenderingContext2D::globalCompositeOperation() const
 678 {
 679     return compositeOperatorName(state().globalComposite, state().globalBlend);
 680 }
 681
 682 void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
 683 {
 684     CompositeOperator op = CompositeSourceOver;
 685     BlendMode blendMode = BlendModeNormal;
 686     if (!parseCompositeAndBlendOperator(operation, op, blendMode))
 687         return;
 688     if ((state().globalComposite == op) && (state().globalBlend == blendMode))
 689         return;
 690     realizeSaves();
 691     modifiableState().globalComposite = op;
 692     modifiableState().globalBlend = blendMode;
 693     GraphicsContext* c = drawingContext();
 694     if (!c)
 695         return;
 696     c->setCompositeOperation(op, blendMode);
 697 }
 698
 699 void CanvasRenderingContext2D::scale(float sx, float sy)
 700 {
 701     GraphicsContext* c = drawingContext();
 702     if (!c)
 703         return;
 704     if (!state().hasInvertibleTransform)
 705         return;
 706
 707     if (!std::isfinite(sx) || !std::isfinite(sy))
 708         return;
 709
 710     AffineTransform newTransform = state().transform;
 711     newTransform.scaleNonUniform(sx, sy);
 712     if (state().transform == newTransform)
 713         return;
 714
 715     realizeSaves();
 716
 717     if (!sx || !sy) {
 718         modifiableState().hasInvertibleTransform = false;
 719         return;
 720     }
 721
 722     modifiableState().transform = newTransform;
 723     c->scale(FloatSize(sx, sy));
 724     m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));
 725 }
 726
 727 void CanvasRenderingContext2D::rotate(float angleInRadians)
 728 {
 729     GraphicsContext* c = drawingContext();
 730     if (!c)
 731         return;
 732     if (!state().hasInvertibleTransform)
 733         return;
 734
 735     if (!std::isfinite(angleInRadians))
 736         return;
 737
 738     AffineTransform newTransform = state().transform;
 739     newTransform.rotate(angleInRadians / piDouble * 180.0);
 740     if (state().transform == newTransform)
 741         return;
 742
 743     realizeSaves();
 744
 745     modifiableState().transform = newTransform;
 746     c->rotate(angleInRadians);
 747     m_path.transform(AffineTransform().rotate(-angleInRadians / piDouble * 180.0));
 748 }
 749
 750 void CanvasRenderingContext2D::translate(float tx, float ty)
 751 {
 752     GraphicsContext* c = drawingContext();
 753     if (!c)
 754         return;
 755     if (!state().hasInvertibleTransform)
 756         return;
 757
 758     if (!std::isfinite(tx) | !std::isfinite(ty))
 759         return;
 760
 761     AffineTransform newTransform = state().transform;
 762     newTransform.translate(tx, ty);
 763     if (state().transform == newTransform)
 764         return;
 765
 766     realizeSaves();
 767
 768     modifiableState().transform = newTransform;
 769     c->translate(tx, ty);
 770     m_path.transform(AffineTransform().translate(-tx, -ty));
 771 }
 772
 773 void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)
 774 {
 775     GraphicsContext* c = drawingContext();
 776     if (!c)
 777         return;
 778     if (!state().hasInvertibleTransform)
 779         return;
 780
 781     if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy))
 782         return;
 783
 784     AffineTransform transform(m11, m12, m21, m22, dx, dy);
 785     AffineTransform newTransform = state().transform * transform;
 786     if (state().transform == newTransform)
 787         return;
 788
 789     realizeSaves();
 790
 791     if (auto inverse = transform.inverse()) {
 792         modifiableState().transform = newTransform;
 793         c->concatCTM(transform);
 794         m_path.transform(inverse.value());
 795         return;
 796     }
 797     modifiableState().hasInvertibleTransform = false;
 798 }
 799
 800 Ref<DOMMatrix> CanvasRenderingContext2D::getTransform() const
 801 {
 802     return DOMMatrix::create(state().transform.toTransformationMatrix(), DOMMatrixReadOnly::Is2D::Yes);
 803 }
 804
 805 void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)
 806 {
 807     GraphicsContext* c = drawingContext();
 808     if (!c)
 809         return;
 810
 811     if (!std::isfinite(m11) | !std::isfinite(m21) | !std::isfinite(dx) | !std::isfinite(m12) | !std::isfinite(m22) | !std::isfinite(dy))
 812         return;
 813
 814     resetTransform();
 815     transform(m11, m12, m21, m22, dx, dy);
 816 }
 817
 818 ExceptionOr<void> CanvasRenderingContext2D::setTransform(DOMMatrixInit&& matrixInit)
 819 {
 820     auto checkValid = DOMMatrixReadOnly::validateAndFixup(matrixInit);
 821     if (checkValid.hasException())
 822         return checkValid.releaseException();
 823
 824     setTransform(matrixInit.a.value_or(1), matrixInit.b.value_or(0), matrixInit.c.value_or(0), matrixInit.d.value_or(1), matrixInit.e.value_or(0), matrixInit.f.value_or(0));
 825
 826     return { };
 827 }
 828
 829 void CanvasRenderingContext2D::resetTransform()
 830 {
 831     GraphicsContext* c = drawingContext();
 832     if (!c)
 833         return;
 834
 835     AffineTransform ctm = state().transform;
 836     bool hasInvertibleTransform = state().hasInvertibleTransform;
 837
 838     realizeSaves();
 839
 840     c->setCTM(canvas().baseTransform());
 841     modifiableState().transform = AffineTransform();
 842
 843     if (hasInvertibleTransform)
 844         m_path.transform(ctm);
 845
 846     modifiableState().hasInvertibleTransform = true;
 847 }
 848
 849 void CanvasRenderingContext2D::setStrokeColor(const String& color, std::optional<float> alpha)
 850 {
 851     if (alpha) {
 852         setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));
 853         return;
 854     }
 855
 856     if (color == state().unparsedStrokeColor)
 857         return;
 858
 859     realizeSaves();
 860     setStrokeStyle(CanvasStyle::createFromString(color));
 861     modifiableState().unparsedStrokeColor = color;
 862 }
 863
 864 void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)
 865 {
 866     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
 867         return;
 868     setStrokeStyle(CanvasStyle(grayLevel, alpha));
 869 }
 870
 871 void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)
 872 {
 873     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(r, g, b, a))
 874         return;
 875     setStrokeStyle(CanvasStyle(r, g, b, a));
 876 }
 877
 878 void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)
 879 {
 880     if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentCMYKA(c, m, y, k, a))
 881         return;
 882     setStrokeStyle(CanvasStyle(c, m, y, k, a));
 883 }
 884
 885 void CanvasRenderingContext2D::setFillColor(const String& color, std::optional<float> alpha)
 886 {
 887     if (alpha) {
 888         setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha.value()));
 889         return;
 890     }
 891
 892     if (color == state().unparsedFillColor)
 893         return;
 894
 895     realizeSaves();
 896     setFillStyle(CanvasStyle::createFromString(color));
 897     modifiableState().unparsedFillColor = color;
 898 }
 899
 900 void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)
 901 {
 902     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
 903         return;
 904     setFillStyle(CanvasStyle(grayLevel, alpha));
 905 }
 906
 907 void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)
 908 {
 909     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(r, g, b, a))
 910         return;
 911     setFillStyle(CanvasStyle(r, g, b, a));
 912 }
 913
 914 void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a)
 915 {
 916     if (state().fillStyle.isValid() && state().fillStyle.isEquivalentCMYKA(c, m, y, k, a))
 917         return;
 918     setFillStyle(CanvasStyle(c, m, y, k, a));
 919 }
 920
 921 void CanvasRenderingContext2D::beginPath()
 922 {
 923     m_path.clear();
 924 }
 925
 926 static bool validateRectForCanvas(float& x, float& y, float& width, float& height)
 927 {
 928     if (!std::isfinite(x) | !std::isfinite(y) | !std::isfinite(width) | !std::isfinite(height))
 929         return false;
 930
 931     if (!width && !height)
 932         return false;
 933
 934     if (width < 0) {
 935         width = -width;
 936         x -= width;
 937     }
 938
 939     if (height < 0) {
 940         height = -height;
 941         y -= height;
 942     }
 943
 944     return true;
 945 }
 946
 947 inline void CanvasRenderingContext2D::clearPathForDashboardBackwardCompatibilityMode()
 948 {
 949 #if ENABLE(DASHBOARD_SUPPORT)
 950     if (m_usesDashboardCompatibilityMode)
 951         m_path.clear();
 952 #endif
 953 }
 954
 955 static bool isFullCanvasCompositeMode(CompositeOperator op)
 956 {
 957     // See 4.8.11.1.3 Compositing
 958     // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
 959     // implement the specification's behavior.
 960     return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop;
 961 }
 962
 963 static WindRule toWindRule(CanvasRenderingContext2D::WindingRule rule)
 964 {
 965     return rule == CanvasRenderingContext2D::WindingRule::Nonzero ? RULE_NONZERO : RULE_EVENODD;
 966 }
 967
 968 String CanvasRenderingContext2D::stringForWindingRule(WindingRule windingRule)
 969 {
 970     switch (windingRule) {
 971     case WindingRule::Nonzero:
 972         return ASCIILiteral("nonzero");
 973     case WindingRule::Evenodd:
 974         return ASCIILiteral("evenodd");
 975     }
 976
 977     ASSERT_NOT_REACHED();
 978     return String();
 979 }
 980
 981 void CanvasRenderingContext2D::fill(WindingRule windingRule)
 982 {
 983     fillInternal(m_path, windingRule);
 984     clearPathForDashboardBackwardCompatibilityMode();
 985 }
 986
 987 void CanvasRenderingContext2D::stroke()
 988 {
 989     strokeInternal(m_path);
 990     clearPathForDashboardBackwardCompatibilityMode();
 991 }
 992
 993 void CanvasRenderingContext2D::clip(WindingRule windingRule)
 994 {
 995     clipInternal(m_path, windingRule);
 996     clearPathForDashboardBackwardCompatibilityMode();
 997 }
 998
 999 void CanvasRenderingContext2D::fill(DOMPath& path, WindingRule windingRule)
1000 {
1001     fillInternal(path.path(), windingRule);
1002 }
1003
1004 void CanvasRenderingContext2D::stroke(DOMPath& path)
1005 {
1006     strokeInternal(path.path());
1007 }
1008
1009 void CanvasRenderingContext2D::clip(DOMPath& path, WindingRule windingRule)
1010 {
1011     clipInternal(path.path(), windingRule);
1012 }
1013
1014 void CanvasRenderingContext2D::fillInternal(const Path& path, WindingRule windingRule)
1015 {
1016     auto* c = drawingContext();
1017     if (!c)
1018         return;
1019     if (!state().hasInvertibleTransform)
1020         return;
1021
1022     // If gradient size is zero, then paint nothing.
1023     auto* gradient = c->fillGradient();
1024     if (gradient && gradient->isZeroSize())
1025         return;
1026
1027     if (!path.isEmpty()) {
1028         auto savedFillRule = c->fillRule();
1029         c->setFillRule(toWindRule(windingRule));
1030
1031         if (isFullCanvasCompositeMode(state().globalComposite)) {
1032             beginCompositeLayer();
1033             c->fillPath(path);
1034             endCompositeLayer();
1035             didDrawEntireCanvas();
1036         } else if (state().globalComposite == CompositeCopy) {
1037             clearCanvas();
1038             c->fillPath(path);
1039             didDrawEntireCanvas();
1040         } else {
1041             c->fillPath(path);
1042             didDraw(path.fastBoundingRect());
1043         }
1044
1045         c->setFillRule(savedFillRule);
1046     }
1047 }
1048
1049 void CanvasRenderingContext2D::strokeInternal(const Path& path)
1050 {
1051     auto* c = drawingContext();
1052     if (!c)
1053         return;
1054     if (!state().hasInvertibleTransform)
1055         return;
1056
1057     // If gradient size is zero, then paint nothing.
1058     auto* gradient = c->strokeGradient();
1059     if (gradient && gradient->isZeroSize())
1060         return;
1061
1062     if (!path.isEmpty()) {
1063         if (isFullCanvasCompositeMode(state().globalComposite)) {
1064             beginCompositeLayer();
1065             c->strokePath(path);
1066             endCompositeLayer();
1067             didDrawEntireCanvas();
1068         } else if (state().globalComposite == CompositeCopy) {
1069             clearCanvas();
1070             c->strokePath(path);
1071             didDrawEntireCanvas();
1072         } else {
1073             FloatRect dirtyRect = path.fastBoundingRect();
1074             inflateStrokeRect(dirtyRect);
1075             c->strokePath(path);
1076             didDraw(dirtyRect);
1077         }
1078     }
1079 }
1080
1081 void CanvasRenderingContext2D::clipInternal(const Path& path, WindingRule windingRule)
1082 {
1083     auto* c = drawingContext();
1084     if (!c)
1085         return;
1086     if (!state().hasInvertibleTransform)
1087         return;
1088
1089     realizeSaves();
1090     c->canvasClip(path, toWindRule(windingRule));
1091 }
1092
1093 inline void CanvasRenderingContext2D::beginCompositeLayer()
1094 {
1095 #if !USE(CAIRO)
1096     drawingContext()->beginTransparencyLayer(1);
1097 #endif
1098 }
1099
1100 inline void CanvasRenderingContext2D::endCompositeLayer()
1101 {
1102 #if !USE(CAIRO)
1103     drawingContext()->endTransparencyLayer();
1104 #endif
1105 }
1106
1107 bool CanvasRenderingContext2D::isPointInPath(float x, float y, WindingRule windingRule)
1108 {
1109     return isPointInPathInternal(m_path, x, y, windingRule);
1110 }
1111
1112 bool CanvasRenderingContext2D::isPointInStroke(float x, float y)
1113 {
1114     return isPointInStrokeInternal(m_path, x, y);
1115 }
1116
1117 bool CanvasRenderingContext2D::isPointInPath(DOMPath& path, float x, float y, WindingRule windingRule)
1118 {
1119     return isPointInPathInternal(path.path(), x, y, windingRule);
1120 }
1121
1122 bool CanvasRenderingContext2D::isPointInStroke(DOMPath& path, float x, float y)
1123 {
1124     return isPointInStrokeInternal(path.path(), x, y);
1125 }
1126
1127 bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, float x, float y, WindingRule windingRule)
1128 {
1129     auto* c = drawingContext();
1130     if (!c)
1131         return false;
1132     if (!state().hasInvertibleTransform)
1133         return false;
1134
1135     auto transformedPoint = state().transform.inverse().value_or(AffineTransform()).mapPoint(FloatPoint(x, y));
1136
1137     if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))
1138         return false;
1139
1140     return path.contains(transformedPoint, toWindRule(windingRule));
1141 }
1142
1143 bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, float x, float y)
1144 {
1145     auto* c = drawingContext();
1146     if (!c)
1147         return false;
1148     if (!state().hasInvertibleTransform)
1149         return false;
1150
1151     auto transformedPoint = state().transform.inverse().value_or(AffineTransform()).mapPoint(FloatPoint(x, y));
1152     if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))
1153         return false;
1154
1155     CanvasStrokeStyleApplier applier(this);
1156     return path.strokeContains(&applier, transformedPoint);
1157 }
1158
1159 void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
1160 {
1161     if (!validateRectForCanvas(x, y, width, height))
1162         return;
1163     auto* context = drawingContext();
1164     if (!context)
1165         return;
1166     if (!state().hasInvertibleTransform)
1167         return;
1168     FloatRect rect(x, y, width, height);
1169
1170     bool saved = false;
1171     if (shouldDrawShadows()) {
1172         context->save();
1173         saved = true;
1174         context->setLegacyShadow(FloatSize(), 0, Color::transparent);
1175     }
1176     if (state().globalAlpha != 1) {
1177         if (!saved) {
1178             context->save();
1179             saved = true;
1180         }
1181         context->setAlpha(1);
1182     }
1183     if (state().globalComposite != CompositeSourceOver) {
1184         if (!saved) {
1185             context->save();
1186             saved = true;
1187         }
1188         context->setCompositeOperation(CompositeSourceOver);
1189     }
1190     context->clearRect(rect);
1191     if (saved)
1192         context->restore();
1193     didDraw(rect);
1194 }
1195
1196 void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
1197 {
1198     if (!validateRectForCanvas(x, y, width, height))
1199         return;
1200
1201     auto* c = drawingContext();
1202     if (!c)
1203         return;
1204     if (!state().hasInvertibleTransform)
1205         return;
1206
1207     // from the HTML5 Canvas spec:
1208     // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing
1209     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
1210     auto* gradient = c->fillGradient();
1211     if (gradient && gradient->isZeroSize())
1212         return;
1213
1214     FloatRect rect(x, y, width, height);
1215
1216     if (rectContainsCanvas(rect)) {
1217         c->fillRect(rect);
1218         didDrawEntireCanvas();
1219     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
1220         beginCompositeLayer();
1221         c->fillRect(rect);
1222         endCompositeLayer();
1223         didDrawEntireCanvas();
1224     } else if (state().globalComposite == CompositeCopy) {
1225         clearCanvas();
1226         c->fillRect(rect);
1227         didDrawEntireCanvas();
1228     } else {
1229         c->fillRect(rect);
1230         didDraw(rect);
1231     }
1232 }
1233
1234 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
1235 {
1236     if (!validateRectForCanvas(x, y, width, height))
1237         return;
1238
1239     auto* c = drawingContext();
1240     if (!c)
1241         return;
1242     if (!state().hasInvertibleTransform)
1243         return;
1244     if (!(state().lineWidth >= 0))
1245         return;
1246
1247     // If gradient size is zero, then paint nothing.
1248     auto* gradient = c->strokeGradient();
1249     if (gradient && gradient->isZeroSize())
1250         return;
1251
1252     FloatRect rect(x, y, width, height);
1253     if (isFullCanvasCompositeMode(state().globalComposite)) {
1254         beginCompositeLayer();
1255         c->strokeRect(rect, state().lineWidth);
1256         endCompositeLayer();
1257         didDrawEntireCanvas();
1258     } else if (state().globalComposite == CompositeCopy) {
1259         clearCanvas();
1260         c->strokeRect(rect, state().lineWidth);
1261         didDrawEntireCanvas();
1262     } else {
1263         FloatRect boundingRect = rect;
1264         boundingRect.inflate(state().lineWidth / 2);
1265         c->strokeRect(rect, state().lineWidth);
1266         didDraw(boundingRect);
1267     }
1268 }
1269
1270 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& colorString, std::optional<float> alpha)
1271 {
1272     Color color = Color::transparent;
1273     if (!colorString.isNull()) {
1274         color = parseColorOrCurrentColor(colorString, &canvas());
1275         if (!color.isValid())
1276             return;
1277     }
1278     // FIXME: Should not use RGBA32 here.
1279     setShadow(FloatSize(width, height), blur, colorWithOverrideAlpha(color.rgb(), alpha));
1280 }
1281
1282 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)
1283 {
1284     setShadow(FloatSize(width, height), blur, Color(grayLevel, grayLevel, grayLevel, alpha));
1285 }
1286
1287 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)
1288 {
1289     setShadow(FloatSize(width, height), blur, Color(r, g, b, a));
1290 }
1291
1292 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
1293 {
1294     setShadow(FloatSize(width, height), blur, Color(c, m, y, k, a));
1295 }
1296
1297 void CanvasRenderingContext2D::clearShadow()
1298 {
1299     setShadow(FloatSize(), 0, Color::transparent);
1300 }
1301
1302 void CanvasRenderingContext2D::setShadow(const FloatSize& offset, float blur, const Color& color)
1303 {
1304     if (state().shadowOffset == offset && state().shadowBlur == blur && state().shadowColor == color)
1305         return;
1306     bool wasDrawingShadows = shouldDrawShadows();
1307     realizeSaves();
1308     modifiableState().shadowOffset = offset;
1309     modifiableState().shadowBlur = blur;
1310     modifiableState().shadowColor = color;
1311     if (!wasDrawingShadows && !shouldDrawShadows())
1312         return;
1313     applyShadow();
1314 }
1315
1316 void CanvasRenderingContext2D::applyShadow()
1317 {
1318     auto* c = drawingContext();
1319     if (!c)
1320         return;
1321
1322     if (shouldDrawShadows()) {
1323         float width = state().shadowOffset.width();
1324         float height = state().shadowOffset.height();
1325         c->setLegacyShadow(FloatSize(width, -height), state().shadowBlur, state().shadowColor);
1326     } else
1327         c->setLegacyShadow(FloatSize(), 0, Color::transparent);
1328 }
1329
1330 bool CanvasRenderingContext2D::shouldDrawShadows() const
1331 {
1332     return state().shadowColor.isVisible() && (state().shadowBlur || !state().shadowOffset.isZero());
1333 }
1334
1335 enum class ImageSizeType { AfterDevicePixelRatio, BeforeDevicePixelRatio };
1336 static LayoutSize size(HTMLImageElement& element, ImageSizeType sizeType = ImageSizeType::BeforeDevicePixelRatio)
1337 {
1338     LayoutSize size;
1339     if (auto* cachedImage = element.cachedImage()) {
1340         size = cachedImage->imageSizeForRenderer(element.renderer(), 1.0f); // FIXME: Not sure about this.
1341         if (sizeType == ImageSizeType::AfterDevicePixelRatio && is<RenderImage>(element.renderer()) && cachedImage->image() && !cachedImage->image()->hasRelativeWidth())
1342             size.scale(downcast<RenderImage>(*element.renderer()).imageDevicePixelRatio());
1343     }
1344     return size;
1345 }
1346
1347 static inline FloatSize size(HTMLCanvasElement& canvasElement)
1348 {
1349     return canvasElement.size();
1350 }
1351
1352 #if ENABLE(VIDEO)
1353
1354 static inline FloatSize size(HTMLVideoElement& video)
1355 {
1356     auto* player = video.player();
1357     if (!player)
1358         return { };
1359     return player->naturalSize();
1360 }
1361
1362 #endif
1363
1364 static inline FloatRect normalizeRect(const FloatRect& rect)
1365 {
1366     return FloatRect(std::min(rect.x(), rect.maxX()),
1367         std::min(rect.y(), rect.maxY()),
1368         std::max(rect.width(), -rect.width()),
1369         std::max(rect.height(), -rect.height()));
1370 }
1371
1372 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy)
1373 {
1374     return WTF::switchOn(image,
1375         [&] (RefPtr<HTMLImageElement>& imageElement) -> ExceptionOr<void> {
1376             LayoutSize destRectSize = size(*imageElement, ImageSizeType::AfterDevicePixelRatio);
1377             LayoutSize sourceRectSize = size(*imageElement, ImageSizeType::BeforeDevicePixelRatio);
1378             return this->drawImage(*imageElement, FloatRect { 0, 0, sourceRectSize.width(), sourceRectSize.height() }, FloatRect { dx, dy, destRectSize.width(), destRectSize.height() });
1379         },
1380         [&] (auto& element) -> ExceptionOr<void> {
1381             FloatSize elementSize = size(*element);
1382             return this->drawImage(*element, FloatRect { 0, 0, elementSize.width(), elementSize.height() }, FloatRect { dx, dy, elementSize.width(), elementSize.height() });
1383         }
1384     );
1385 }
1386
1387 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float dx, float dy, float dw, float dh)
1388 {
1389     return WTF::switchOn(image,
1390         [&] (auto& element) -> ExceptionOr<void> {
1391             FloatSize elementSize = size(*element);
1392             return this->drawImage(*element, FloatRect { 0, 0, elementSize.width(), elementSize.height() }, FloatRect { dx, dy, dw, dh });
1393         }
1394     );
1395 }
1396
1397 ExceptionOr<void> CanvasRenderingContext2D::drawImage(CanvasImageSource&& image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)
1398 {
1399     return WTF::switchOn(image,
1400         [&] (auto& element) -> ExceptionOr<void> {
1401             return this->drawImage(*element, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh });
1402         }
1403     );
1404 }
1405
1406 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect)
1407 {
1408     return drawImage(imageElement, srcRect, dstRect, state().globalComposite, state().globalBlend);
1409 }
1410
1411 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
1412 {
1413     if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height())
1414         || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height()))
1415         return { };
1416
1417     if (!dstRect.width() || !dstRect.height())
1418         return { };
1419
1420     if (!imageElement.complete())
1421         return { };
1422
1423     FloatRect normalizedSrcRect = normalizeRect(srcRect);
1424     FloatRect normalizedDstRect = normalizeRect(dstRect);
1425
1426     FloatRect imageRect = FloatRect(FloatPoint(), size(imageElement, ImageSizeType::BeforeDevicePixelRatio));
1427     if (!srcRect.width() || !srcRect.height())
1428         return Exception { IndexSizeError };
1429
1430     // When the source rectangle is outside the source image, the source rectangle must be clipped
1431     // to the source image and the destination rectangle must be clipped in the same proportion.
1432     FloatRect originalNormalizedSrcRect = normalizedSrcRect;
1433     normalizedSrcRect.intersect(imageRect);
1434     if (normalizedSrcRect.isEmpty())
1435         return { };
1436
1437     if (normalizedSrcRect != originalNormalizedSrcRect) {
1438         normalizedDstRect.setWidth(normalizedDstRect.width() * normalizedSrcRect.width() / originalNormalizedSrcRect.width());
1439         normalizedDstRect.setHeight(normalizedDstRect.height() * normalizedSrcRect.height() / originalNormalizedSrcRect.height());
1440         if (normalizedDstRect.isEmpty())
1441             return { };
1442     }
1443
1444     GraphicsContext* c = drawingContext();
1445     if (!c)
1446         return { };
1447     if (!state().hasInvertibleTransform)
1448         return { };
1449
1450     CachedImage* cachedImage = imageElement.cachedImage();
1451     if (!cachedImage)
1452         return { };
1453
1454     Image* image = cachedImage->imageForRenderer(imageElement.renderer());
1455     if (!image)
1456         return { };
1457
1458     ImageObserver* observer = image->imageObserver();
1459
1460     if (image->isSVGImage()) {
1461         image->setImageObserver(nullptr);
1462         image->setContainerSize(imageRect.size());
1463     }
1464
1465     if (image->isBitmapImage())
1466         downcast<BitmapImage>(*image).updateFromSettings(imageElement.document().settings());
1467
1468     if (rectContainsCanvas(normalizedDstRect)) {
1469         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1470         didDrawEntireCanvas();
1471     } else if (isFullCanvasCompositeMode(op)) {
1472         fullCanvasCompositedDrawImage(*image, normalizedDstRect, normalizedSrcRect, op);
1473         didDrawEntireCanvas();
1474     } else if (op == CompositeCopy) {
1475         clearCanvas();
1476         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1477         didDrawEntireCanvas();
1478     } else {
1479         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
1480         didDraw(normalizedDstRect);
1481     }
1482
1483     if (image->isSVGImage())
1484         image->setImageObserver(observer);
1485
1486     checkOrigin(&imageElement);
1487
1488     return { };
1489 }
1490
1491 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, const FloatRect& srcRect, const FloatRect& dstRect)
1492 {
1493     FloatRect srcCanvasRect = FloatRect(FloatPoint(), sourceCanvas.size());
1494
1495     if (!srcCanvasRect.width() || !srcCanvasRect.height())
1496         return Exception { InvalidStateError };
1497
1498     if (!srcRect.width() || !srcRect.height())
1499         return Exception { IndexSizeError };
1500
1501     if (!srcCanvasRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
1502         return { };
1503
1504     GraphicsContext* c = drawingContext();
1505     if (!c)
1506         return { };
1507     if (!state().hasInvertibleTransform)
1508         return { };
1509
1510     // FIXME: Do this through platform-independent GraphicsContext API.
1511     ImageBuffer* buffer = sourceCanvas.buffer();
1512     if (!buffer)
1513         return { };
1514
1515     checkOrigin(&sourceCanvas);
1516
1517 #if ENABLE(ACCELERATED_2D_CANVAS)
1518     // If we're drawing from one accelerated canvas 2d to another, avoid calling sourceCanvas.makeRenderingResultsAvailable()
1519     // as that will do a readback to software.
1520     CanvasRenderingContext* sourceContext = sourceCanvas.renderingContext();
1521     // FIXME: Implement an accelerated path for drawing from a WebGL canvas to a 2d canvas when possible.
1522     if (!isAccelerated() || !sourceContext || !sourceContext->isAccelerated() || !sourceContext->is2d())
1523         sourceCanvas.makeRenderingResultsAvailable();
1524 #else
1525     sourceCanvas.makeRenderingResultsAvailable();
1526 #endif
1527
1528     if (rectContainsCanvas(dstRect)) {
1529         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1530         didDrawEntireCanvas();
1531     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
1532         fullCanvasCompositedDrawImage(*buffer, dstRect, srcRect, state().globalComposite);
1533         didDrawEntireCanvas();
1534     } else if (state().globalComposite == CompositeCopy) {
1535         clearCanvas();
1536         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1537         didDrawEntireCanvas();
1538     } else {
1539         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
1540         didDraw(dstRect);
1541     }
1542
1543     return { };
1544 }
1545
1546 #if ENABLE(VIDEO)
1547
1548 ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRect& srcRect, const FloatRect& dstRect)
1549 {
1550     if (video.readyState() == HTMLMediaElement::HAVE_NOTHING || video.readyState() == HTMLMediaElement::HAVE_METADATA)
1551         return { };
1552
1553     FloatRect videoRect = FloatRect(FloatPoint(), size(video));
1554     if (!srcRect.width() || !srcRect.height())
1555         return Exception { IndexSizeError };
1556
1557     if (!videoRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
1558         return { };
1559
1560     GraphicsContext* c = drawingContext();
1561     if (!c)
1562         return { };
1563     if (!state().hasInvertibleTransform)
1564         return { };
1565
1566     checkOrigin(&video);
1567
1568 #if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
1569     if (NativeImagePtr image = video.nativeImageForCurrentTime()) {
1570         c->drawNativeImage(image, FloatSize(video.videoWidth(), video.videoHeight()), dstRect, srcRect);
1571         if (rectContainsCanvas(dstRect))
1572             didDrawEntireCanvas();
1573         else
1574             didDraw(dstRect);
1575
1576         return { };
1577     }
1578 #endif
1579
1580     GraphicsContextStateSaver stateSaver(*c);
1581     c->clip(dstRect);
1582     c->translate(dstRect.x(), dstRect.y());
1583     c->scale(FloatSize(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height()));
1584     c->translate(-srcRect.x(), -srcRect.y());
1585     video.paintCurrentFrameInContext(*c, FloatRect(FloatPoint(), size(video)));
1586     stateSaver.restore();
1587     didDraw(dstRect);
1588
1589     return { };
1590 }
1591
1592 #endif
1593
1594 void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation)
1595 {
1596     CompositeOperator op;
1597     auto blendOp = BlendModeNormal;
1598     if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal)
1599         op = CompositeSourceOver;
1600     drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh }, op, BlendModeNormal);
1601 }
1602
1603 void CanvasRenderingContext2D::setAlpha(float alpha)
1604 {
1605     setGlobalAlpha(alpha);
1606 }
1607
1608 void CanvasRenderingContext2D::setCompositeOperation(const String& operation)
1609 {
1610     setGlobalCompositeOperation(operation);
1611 }
1612
1613 void CanvasRenderingContext2D::clearCanvas()
1614 {
1615     auto* c = drawingContext();
1616     if (!c)
1617         return;
1618
1619     c->save();
1620     c->setCTM(canvas().baseTransform());
1621     c->clearRect(FloatRect(0, 0, canvas().width(), canvas().height()));
1622     c->restore();
1623 }
1624
1625 Path CanvasRenderingContext2D::transformAreaToDevice(const Path& path) const
1626 {
1627     Path transformed(path);
1628     transformed.transform(state().transform);
1629     transformed.transform(canvas().baseTransform());
1630     return transformed;
1631 }
1632
1633 Path CanvasRenderingContext2D::transformAreaToDevice(const FloatRect& rect) const
1634 {
1635     Path path;
1636     path.addRect(rect);
1637     return transformAreaToDevice(path);
1638 }
1639
1640 bool CanvasRenderingContext2D::rectContainsCanvas(const FloatRect& rect) const
1641 {
1642     FloatQuad quad(rect);
1643     FloatQuad canvasQuad(FloatRect(0, 0, canvas().width(), canvas().height()));
1644     return state().transform.mapQuad(quad).containsQuad(canvasQuad);
1645 }
1646
1647 template<class T> IntRect CanvasRenderingContext2D::calculateCompositingBufferRect(const T& area, IntSize* croppedOffset)
1648 {
1649     IntRect canvasRect(0, 0, canvas().width(), canvas().height());
1650     canvasRect = canvas().baseTransform().mapRect(canvasRect);
1651     Path path = transformAreaToDevice(area);
1652     IntRect bufferRect = enclosingIntRect(path.fastBoundingRect());
1653     IntPoint originalLocation = bufferRect.location();
1654     bufferRect.intersect(canvasRect);
1655     if (croppedOffset)
1656         *croppedOffset = originalLocation - bufferRect.location();
1657     return bufferRect;
1658 }
1659
1660 std::unique_ptr<ImageBuffer> CanvasRenderingContext2D::createCompositingBuffer(const IntRect& bufferRect)
1661 {
1662     return ImageBuffer::create(bufferRect.size(), isAccelerated() ? Accelerated : Unaccelerated);
1663 }
1664
1665 void CanvasRenderingContext2D::compositeBuffer(ImageBuffer& buffer, const IntRect& bufferRect, CompositeOperator op)
1666 {
1667     IntRect canvasRect(0, 0, canvas().width(), canvas().height());
1668     canvasRect = canvas().baseTransform().mapRect(canvasRect);
1669
1670     auto* c = drawingContext();
1671     if (!c)
1672         return;
1673
1674     c->save();
1675     c->setCTM(AffineTransform());
1676     c->setCompositeOperation(op);
1677
1678     c->save();
1679     c->clipOut(bufferRect);
1680     c->clearRect(canvasRect);
1681     c->restore();
1682     c->drawImageBuffer(buffer, bufferRect.location(), state().globalComposite);
1683     c->restore();
1684 }
1685
1686 static void drawImageToContext(Image& image, GraphicsContext& context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1687 {
1688     context.drawImage(image, dest, src, op);
1689 }
1690
1691 static void drawImageToContext(ImageBuffer& imageBuffer, GraphicsContext& context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1692 {
1693     context.drawImageBuffer(imageBuffer, dest, src, op);
1694 }
1695
1696 template<class T> void CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T& image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
1697 {
1698     ASSERT(isFullCanvasCompositeMode(op));
1699
1700     IntSize croppedOffset;
1701     auto bufferRect = calculateCompositingBufferRect(dest, &croppedOffset);
1702     if (bufferRect.isEmpty()) {
1703         clearCanvas();
1704         return;
1705     }
1706
1707     auto buffer = createCompositingBuffer(bufferRect);
1708     if (!buffer)
1709         return;
1710
1711     auto* c = drawingContext();
1712     if (!c)
1713         return;
1714
1715     FloatRect adjustedDest = dest;
1716     adjustedDest.setLocation(FloatPoint(0, 0));
1717     AffineTransform effectiveTransform = c->getCTM();
1718     IntRect transformedAdjustedRect = enclosingIntRect(effectiveTransform.mapRect(adjustedDest));
1719     buffer->context().translate(-transformedAdjustedRect.location().x(), -transformedAdjustedRect.location().y());
1720     buffer->context().translate(croppedOffset.width(), croppedOffset.height());
1721     buffer->context().concatCTM(effectiveTransform);
1722     drawImageToContext(image, buffer->context(), adjustedDest, src, CompositeSourceOver);
1723
1724     compositeBuffer(*buffer, bufferRect, op);
1725 }
1726
1727 void CanvasRenderingContext2D::prepareGradientForDashboard(CanvasGradient& gradient) const
1728 {
1729 #if ENABLE(DASHBOARD_SUPPORT)
1730     if (m_usesDashboardCompatibilityMode)
1731         gradient.setDashboardCompatibilityMode();
1732 #else
1733     UNUSED_PARAM(gradient);
1734 #endif
1735 }
1736
1737 static CanvasRenderingContext2D::Style toStyle(const CanvasStyle& style)
1738 {
1739     if (auto* gradient = style.canvasGradient())
1740         return RefPtr<CanvasGradient> { gradient };
1741     if (auto* pattern = style.canvasPattern())
1742         return RefPtr<CanvasPattern> { pattern };
1743     return style.color();
1744 }
1745
1746 CanvasRenderingContext2D::Style CanvasRenderingContext2D::strokeStyle() const
1747 {
1748     return toStyle(state().strokeStyle);
1749 }
1750
1751 void CanvasRenderingContext2D::setStrokeStyle(CanvasRenderingContext2D::Style&& style)
1752 {
1753     WTF::switchOn(style,
1754         [this] (const String& string) { this->setStrokeColor(string); },
1755         [this] (const RefPtr<CanvasGradient>& gradient) { this->setStrokeStyle(CanvasStyle(*gradient)); },
1756         [this] (const RefPtr<CanvasPattern>& pattern) { this->setStrokeStyle(CanvasStyle(*pattern)); }
1757     );
1758 }
1759
1760 CanvasRenderingContext2D::Style CanvasRenderingContext2D::fillStyle() const
1761 {
1762     return toStyle(state().fillStyle);
1763 }
1764
1765 void CanvasRenderingContext2D::setFillStyle(CanvasRenderingContext2D::Style&& style)
1766 {
1767     WTF::switchOn(style,
1768         [this] (const String& string) { this->setFillColor(string); },
1769         [this] (const RefPtr<CanvasGradient>& gradient) { this->setFillStyle(CanvasStyle(*gradient)); },
1770         [this] (const RefPtr<CanvasPattern>& pattern) { this->setFillStyle(CanvasStyle(*pattern)); }
1771     );
1772 }
1773
1774 ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
1775 {
1776     if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1))
1777         return Exception { NotSupportedError };
1778
1779     auto gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
1780     prepareGradientForDashboard(gradient.get());
1781     return WTFMove(gradient);
1782 }
1783
1784 ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1)
1785 {
1786     if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1))
1787         return Exception { NotSupportedError };
1788
1789     if (r0 < 0 || r1 < 0)
1790         return Exception { IndexSizeError };
1791
1792     auto gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
1793     prepareGradientForDashboard(gradient.get());
1794     return WTFMove(gradient);
1795 }
1796
1797 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(CanvasImageSource&& image, const String& repetition)
1798 {
1799     bool repeatX, repeatY;
1800     if (!CanvasPattern::parseRepetitionType(repetition, repeatX, repeatY))
1801         return Exception { SyntaxError };
1802
1803     return WTF::switchOn(image,
1804         [&] (auto& element) -> ExceptionOr<RefPtr<CanvasPattern>> { return this->createPattern(*element, repeatX, repeatY); }
1805     );
1806 }
1807
1808 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLImageElement& imageElement, bool repeatX, bool repeatY)
1809 {
1810     auto* cachedImage = imageElement.cachedImage();
1811
1812     // If the image loading hasn't started or the image is not complete, it is not fully decodable.
1813     if (!cachedImage || !imageElement.complete())
1814         return nullptr;
1815
1816     if (cachedImage->status() == CachedResource::LoadError)
1817         return Exception { InvalidStateError };
1818
1819     bool originClean = cachedImage->isOriginClean(canvas().securityOrigin());
1820
1821     // FIXME: SVG images with animations can switch between clean and dirty (leaking cross-origin
1822     // data). We should either:
1823     //   1) Take a fixed snapshot of an SVG image when creating a pattern and determine then whether
1824     //      the origin is clean.
1825     //   2) Dynamically verify the origin checks at draw time, and dirty the canvas accordingly.
1826     // To be on the safe side, taint the origin for all patterns containing SVG images for now.
1827     if (cachedImage->image()->isSVGImage())
1828         originClean = false;
1829
1830     return RefPtr<CanvasPattern> { CanvasPattern::create(*cachedImage->imageForRenderer(imageElement.renderer()), repeatX, repeatY, originClean) };
1831 }
1832
1833 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLCanvasElement& canvas, bool repeatX, bool repeatY)
1834 {
1835     if (!canvas.width() || !canvas.height() || !canvas.buffer())
1836         return Exception { InvalidStateError };
1837
1838     return RefPtr<CanvasPattern> { CanvasPattern::create(*canvas.copiedImage(), repeatX, repeatY, canvas.originClean()) };
1839 }
1840
1841 #if ENABLE(VIDEO)
1842
1843 ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLVideoElement& videoElement, bool repeatX, bool repeatY)
1844 {
1845     if (videoElement.readyState() < HTMLMediaElement::HAVE_CURRENT_DATA)
1846         return nullptr;
1847
1848     checkOrigin(&videoElement);
1849     bool originClean = canvas().originClean();
1850
1851 #if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
1852     if (auto nativeImage = videoElement.nativeImageForCurrentTime())
1853         return RefPtr<CanvasPattern> { CanvasPattern::create(BitmapImage::create(WTFMove(nativeImage)), repeatX, repeatY, originClean) };
1854 #endif
1855
1856     auto imageBuffer = ImageBuffer::create(size(videoElement), drawingContext() ? drawingContext()->renderingMode() : Accelerated);
1857     videoElement.paintCurrentFrameInContext(imageBuffer->context(), FloatRect(FloatPoint(), size(videoElement)));
1858
1859     return RefPtr<CanvasPattern> { CanvasPattern::create(ImageBuffer::sinkIntoImage(WTFMove(imageBuffer), Unscaled).releaseNonNull(), repeatX, repeatY, originClean) };
1860 }
1861
1862 #endif
1863
1864 void CanvasRenderingContext2D::didDrawEntireCanvas()
1865 {
1866     didDraw(FloatRect(FloatPoint::zero(), canvas().size()), CanvasDidDrawApplyClip);
1867 }
1868
1869 void CanvasRenderingContext2D::didDraw(const FloatRect& r, unsigned options)
1870 {
1871     auto* c = drawingContext();
1872     if (!c)
1873         return;
1874     if (!state().hasInvertibleTransform)
1875         return;
1876
1877 #if ENABLE(ACCELERATED_2D_CANVAS)
1878     // If we are drawing to hardware and we have a composited layer, just call contentChanged().
1879     if (isAccelerated()) {
1880         RenderBox* renderBox = canvas().renderBox();
1881         if (renderBox && renderBox->hasAcceleratedCompositing()) {
1882             renderBox->contentChanged(CanvasPixelsChanged);
1883             canvas().clearCopiedImage();
1884             canvas().notifyObserversCanvasChanged(r);
1885             return;
1886         }
1887     }
1888 #endif
1889
1890     FloatRect dirtyRect = r;
1891     if (options & CanvasDidDrawApplyTransform) {
1892         AffineTransform ctm = state().transform;
1893         dirtyRect = ctm.mapRect(r);
1894     }
1895
1896     if (options & CanvasDidDrawApplyShadow && state().shadowColor.isVisible()) {
1897         // The shadow gets applied after transformation
1898         FloatRect shadowRect(dirtyRect);
1899         shadowRect.move(state().shadowOffset);
1900         shadowRect.inflate(state().shadowBlur);
1901         dirtyRect.unite(shadowRect);
1902     }
1903
1904     if (options & CanvasDidDrawApplyClip) {
1905         // FIXME: apply the current clip to the rectangle. Unfortunately we can't get the clip
1906         // back out of the GraphicsContext, so to take clip into account for incremental painting,
1907         // we'd have to keep the clip path around.
1908     }
1909
1910     canvas().didDraw(dirtyRect);
1911 }
1912
1913 void CanvasRenderingContext2D::setTracksDisplayListReplay(bool tracksDisplayListReplay)
1914 {
1915     if (tracksDisplayListReplay == m_tracksDisplayListReplay)
1916         return;
1917
1918     m_tracksDisplayListReplay = tracksDisplayListReplay;
1919     if (!m_tracksDisplayListReplay)
1920         contextDisplayListMap().remove(this);
1921 }
1922
1923 String CanvasRenderingContext2D::displayListAsText(DisplayList::AsTextFlags flags) const
1924 {
1925     if (!m_recordingContext)
1926         return { };
1927     return m_recordingContext->displayList.asText(flags);
1928 }
1929
1930 String CanvasRenderingContext2D::replayDisplayListAsText(DisplayList::AsTextFlags flags) const
1931 {
1932     auto* displayList = contextDisplayListMap().get(this);
1933     if (!displayList)
1934         return { };
1935     return displayList->asText(flags);
1936 }
1937
1938 void CanvasRenderingContext2D::paintRenderingResultsToCanvas()
1939 {
1940     if (UNLIKELY(m_usesDisplayListDrawing)) {
1941         if (!m_recordingContext)
1942             return;
1943
1944         FloatRect clip(FloatPoint::zero(), canvas().size());
1945         DisplayList::Replayer replayer(*canvas().drawingContext(), m_recordingContext->displayList);
1946
1947         if (UNLIKELY(m_tracksDisplayListReplay)) {
1948             auto replayList = replayer.replay(clip, m_tracksDisplayListReplay);
1949             contextDisplayListMap().add(this, WTFMove(replayList));
1950         } else
1951             replayer.replay(clip);
1952
1953         m_recordingContext->displayList.clear();
1954     }
1955 }
1956
1957 GraphicsContext* CanvasRenderingContext2D::drawingContext() const
1958 {
1959     if (UNLIKELY(m_usesDisplayListDrawing)) {
1960         if (!m_recordingContext)
1961             m_recordingContext = std::make_unique<DisplayListDrawingContext>(FloatRect(FloatPoint::zero(), canvas().size()));
1962         return &m_recordingContext->context;
1963     }
1964
1965     return canvas().drawingContext();
1966 }
1967
1968 static RefPtr<ImageData> createEmptyImageData(const IntSize& size)
1969 {
1970     auto data = ImageData::create(size);
1971     if (data)
1972         data->data()->zeroFill();
1973     return data;
1974 }
1975
1976 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(ImageData* imageData) const
1977 {
1978     if (!imageData)
1979         return Exception { NotSupportedError };
1980
1981     return createEmptyImageData(imageData->size());
1982 }
1983
1984 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(float sw, float sh) const
1985 {
1986     if (!sw || !sh)
1987         return Exception { IndexSizeError };
1988
1989     FloatSize logicalSize(std::abs(sw), std::abs(sh));
1990     if (!logicalSize.isExpressibleAsIntSize())
1991         return nullptr;
1992
1993     IntSize size = expandedIntSize(logicalSize);
1994     if (size.width() < 1)
1995         size.setWidth(1);
1996     if (size.height() < 1)
1997         size.setHeight(1);
1998
1999     return createEmptyImageData(size);
2000 }
2001
2002 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) const
2003 {
2004     return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh);
2005 }
2006
2007 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh) const
2008 {
2009     return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh);
2010 }
2011
2012 ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh) const
2013 {
2014     if (!canvas().originClean()) {
2015         static NeverDestroyed<String> consoleMessage(MAKE_STATIC_STRING_IMPL("Unable to get image data from canvas because the canvas has been tainted by cross-origin data."));
2016         canvas().document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
2017         return Exception { SecurityError };
2018     }
2019
2020     if (!sw || !sh)
2021         return Exception { IndexSizeError };
2022
2023     if (sw < 0) {
2024         sx += sw;
2025         sw = -sw;
2026     }
2027     if (sh < 0) {
2028         sy += sh;
2029         sh = -sh;
2030     }
2031
2032     FloatRect logicalRect(sx, sy, sw, sh);
2033     if (logicalRect.width() < 1)
2034         logicalRect.setWidth(1);
2035     if (logicalRect.height() < 1)
2036         logicalRect.setHeight(1);
2037     if (!logicalRect.isExpressibleAsIntRect())
2038         return nullptr;
2039
2040     IntRect imageDataRect = enclosingIntRect(logicalRect);
2041     ImageBuffer* buffer = canvas().buffer();
2042     if (!buffer)
2043         return createEmptyImageData(imageDataRect.size());
2044
2045     auto byteArray = buffer->getUnmultipliedImageData(imageDataRect, nullptr, coordinateSystem);
2046     if (!byteArray) {
2047         StringBuilder consoleMessage;
2048         consoleMessage.appendLiteral("Unable to get image data from canvas. Requested size was ");
2049         consoleMessage.appendNumber(imageDataRect.width());
2050         consoleMessage.appendLiteral(" x ");
2051         consoleMessage.appendNumber(imageDataRect.height());
2052
2053         canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage.toString());
2054         return Exception { InvalidStateError };
2055     }
2056
2057     return ImageData::create(imageDataRect.size(), byteArray.releaseNonNull());
2058 }
2059
2060 void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy)
2061 {
2062     putImageData(data, dx, dy, 0, 0, data.width(), data.height());
2063 }
2064
2065 void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy)
2066 {
2067     webkitPutImageDataHD(data, dx, dy, 0, 0, data.width(), data.height());
2068 }
2069
2070 void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2071 {
2072     putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2073 }
2074
2075 void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2076 {
2077     putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2078 }
2079
2080 void CanvasRenderingContext2D::drawFocusIfNeeded(Element& element)
2081 {
2082     drawFocusIfNeededInternal(m_path, element);
2083 }
2084
2085 void CanvasRenderingContext2D::drawFocusIfNeeded(DOMPath& path, Element& element)
2086 {
2087     drawFocusIfNeededInternal(path.path(), element);
2088 }
2089
2090 void CanvasRenderingContext2D::drawFocusIfNeededInternal(const Path& path, Element& element)
2091 {
2092     auto* context = drawingContext();
2093     if (!element.focused() || !state().hasInvertibleTransform || path.isEmpty() || !element.isDescendantOf(canvas()) || !context)
2094         return;
2095     context->drawFocusRing(path, 1, 1, RenderTheme::focusRingColor());
2096 }
2097
2098 void CanvasRenderingContext2D::putImageData(ImageData& data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
2099 {
2100     ImageBuffer* buffer = canvas().buffer();
2101     if (!buffer)
2102         return;
2103
2104     if (dirtyWidth < 0) {
2105         dirtyX += dirtyWidth;
2106         dirtyWidth = -dirtyWidth;
2107     }
2108
2109     if (dirtyHeight < 0) {
2110         dirtyY += dirtyHeight;
2111         dirtyHeight = -dirtyHeight;
2112     }
2113
2114     FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
2115     clipRect.intersect(IntRect(0, 0, data.width(), data.height()));
2116     IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));
2117     IntRect destRect = enclosingIntRect(clipRect);
2118     destRect.move(destOffset);
2119     destRect.intersect(IntRect(IntPoint(), coordinateSystem == ImageBuffer::LogicalCoordinateSystem ? buffer->logicalSize() : buffer->internalSize()));
2120     if (destRect.isEmpty())
2121         return;
2122     IntRect sourceRect(destRect);
2123     sourceRect.move(-destOffset);
2124     sourceRect.intersect(IntRect(0, 0, data.width(), data.height()));
2125
2126     if (!sourceRect.isEmpty())
2127         buffer->putByteArray(Unmultiplied, data.data(), IntSize(data.width(), data.height()), sourceRect, IntPoint(destOffset), coordinateSystem);
2128
2129     didDraw(destRect, CanvasDidDrawApplyNone); // ignore transform, shadow and clip
2130 }
2131
2132 String CanvasRenderingContext2D::font() const
2133 {
2134     if (!state().font.realized())
2135         return defaultFont;
2136
2137     StringBuilder serializedFont;
2138     const auto& fontDescription = state().font.fontDescription();
2139
2140     if (fontDescription.italic())
2141         serializedFont.appendLiteral("italic ");
2142     if (fontDescription.variantCaps() == FontVariantCaps::Small)
2143         serializedFont.appendLiteral("small-caps ");
2144
2145     serializedFont.appendNumber(fontDescription.computedPixelSize());
2146     serializedFont.appendLiteral("px");
2147
2148     for (unsigned i = 0; i < fontDescription.familyCount(); ++i) {
2149         if (i)
2150             serializedFont.append(',');
2151         // FIXME: We should append family directly to serializedFont rather than building a temporary string.
2152         String family = fontDescription.familyAt(i);
2153         if (family.startsWith("-webkit-"))
2154             family = family.substring(8);
2155         if (family.contains(' '))
2156             family = makeString('"', family, '"');
2157
2158         serializedFont.append(' ');
2159         serializedFont.append(family);
2160     }
2161
2162     return serializedFont.toString();
2163 }
2164
2165 void CanvasRenderingContext2D::setFont(const String& newFont)
2166 {
2167     if (newFont == state().unparsedFont && state().font.realized())
2168         return;
2169
2170     auto parsedStyle = MutableStyleProperties::create();
2171     CSSParser::parseValue(parsedStyle, CSSPropertyFont, newFont, true, strictToCSSParserMode(!m_usesCSSCompatibilityParseMode));
2172     if (parsedStyle->isEmpty())
2173         return;
2174
2175     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
2176
2177     // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
2178     // the "inherit" and "initial" values must be ignored.
2179     if (fontValue == "inherit" || fontValue == "initial")
2180         return;
2181
2182     // The parse succeeded.
2183     String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves.
2184     realizeSaves();
2185     modifiableState().unparsedFont = newFontSafeCopy;
2186
2187     // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work
2188     // relative to the canvas.
2189     auto newStyle = RenderStyle::createPtr();
2190
2191     Document& document = canvas().document();
2192     document.updateStyleIfNeeded();
2193
2194     if (auto* computedStyle = canvas().computedStyle())
2195         newStyle->setFontDescription(computedStyle->fontDescription());
2196     else {
2197         FontCascadeDescription defaultFontDescription;
2198         defaultFontDescription.setOneFamily(defaultFontFamily);
2199         defaultFontDescription.setSpecifiedSize(defaultFontSize);
2200         defaultFontDescription.setComputedSize(defaultFontSize);
2201
2202         newStyle->setFontDescription(defaultFontDescription);
2203     }
2204
2205     newStyle->fontCascade().update(&document.fontSelector());
2206
2207     // Now map the font property longhands into the style.
2208     StyleResolver& styleResolver = canvas().styleResolver();
2209     styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), WTFMove(newStyle));
2210     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());
2211     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariantCaps, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariantCaps).get());
2212     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontWeight, parsedStyle->getPropertyCSSValue(CSSPropertyFontWeight).get());
2213
2214     // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
2215     // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
2216     // The updateFont() calls below update the fontMetrics and ensure the proper setting of font-size and line-height.
2217     styleResolver.updateFont();
2218     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontSize, parsedStyle->getPropertyCSSValue(CSSPropertyFontSize).get());
2219     styleResolver.updateFont();
2220     styleResolver.applyPropertyToCurrentStyle(CSSPropertyLineHeight, parsedStyle->getPropertyCSSValue(CSSPropertyLineHeight).get());
2221
2222     modifiableState().font.initialize(document.fontSelector(), *styleResolver.style());
2223 }
2224
2225 String CanvasRenderingContext2D::textAlign() const
2226 {
2227     return textAlignName(state().textAlign);
2228 }
2229
2230 void CanvasRenderingContext2D::setTextAlign(const String& s)
2231 {
2232     TextAlign align;
2233     if (!parseTextAlign(s, align))
2234         return;
2235     if (state().textAlign == align)
2236         return;
2237     realizeSaves();
2238     modifiableState().textAlign = align;
2239 }
2240
2241 String CanvasRenderingContext2D::textBaseline() const
2242 {
2243     return textBaselineName(state().textBaseline);
2244 }
2245
2246 void CanvasRenderingContext2D::setTextBaseline(const String& s)
2247 {
2248     TextBaseline baseline;
2249     if (!parseTextBaseline(s, baseline))
2250         return;
2251     if (state().textBaseline == baseline)
2252         return;
2253     realizeSaves();
2254     modifiableState().textBaseline = baseline;
2255 }
2256
2257 inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, const RenderStyle** computedStyle) const
2258 {
2259     auto* style = (computedStyle || direction == Direction::Inherit) ? canvas().computedStyle() : nullptr;
2260     if (computedStyle)
2261         *computedStyle = style;
2262     switch (direction) {
2263     case Direction::Inherit:
2264         return style ? style->direction() : LTR;
2265     case Direction::RTL:
2266         return RTL;
2267     case Direction::LTR:
2268         return LTR;
2269     }
2270     ASSERT_NOT_REACHED();
2271     return LTR;
2272 }
2273
2274 String CanvasRenderingContext2D::direction() const
2275 {
2276     if (state().direction == Direction::Inherit)
2277         canvas().document().updateStyleIfNeeded();
2278     return toTextDirection(state().direction) == RTL ? ASCIILiteral("rtl") : ASCIILiteral("ltr");
2279 }
2280
2281 void CanvasRenderingContext2D::setDirection(const String& directionString)
2282 {
2283     Direction direction;
2284     if (directionString == "inherit")
2285         direction = Direction::Inherit;
2286     else if (directionString == "rtl")
2287         direction = Direction::RTL;
2288     else if (directionString == "ltr")
2289         direction = Direction::LTR;
2290     else
2291         return;
2292
2293     if (state().direction == direction)
2294         return;
2295
2296     realizeSaves();
2297     modifiableState().direction = direction;
2298 }
2299
2300 void CanvasRenderingContext2D::fillText(const String& text, float x, float y, std::optional<float> maxWidth)
2301 {
2302     drawTextInternal(text, x, y, true, maxWidth);
2303 }
2304
2305 void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, std::optional<float> maxWidth)
2306 {
2307     drawTextInternal(text, x, y, false, maxWidth);
2308 }
2309
2310 static inline bool isSpaceThatNeedsReplacing(UChar c)
2311 {
2312     // According to specification all space characters should be replaced with 0x0020 space character.
2313     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#text-preparation-algorithm
2314     // The space characters according to specification are : U+0020, U+0009, U+000A, U+000C, and U+000D.
2315     // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#space-character
2316     // This function returns true for 0x000B also, so that this is backward compatible.
2317     // Otherwise, the test LayoutTests/canvas/philip/tests/2d.text.draw.space.collapse.space.html will fail
2318     return c == 0x0009 || c == 0x000A || c == 0x000B || c == 0x000C || c == 0x000D;
2319 }
2320
2321 static void normalizeSpaces(String& text)
2322 {
2323     size_t i = text.find(isSpaceThatNeedsReplacing);
2324     if (i == notFound)
2325         return;
2326
2327     unsigned textLength = text.length();
2328     Vector<UChar> charVector(textLength);
2329     StringView(text).getCharactersWithUpconvert(charVector.data());
2330
2331     charVector[i++] = ' ';
2332
2333     for (; i < textLength; ++i) {
2334         if (isSpaceThatNeedsReplacing(charVector[i]))
2335             charVector[i] = ' ';
2336     }
2337     text = String::adopt(WTFMove(charVector));
2338 }
2339
2340 Ref<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)
2341 {
2342     Ref<TextMetrics> metrics = TextMetrics::create();
2343
2344     String normalizedText = text;
2345     normalizeSpaces(normalizedText);
2346
2347     metrics->setWidth(fontProxy().width(TextRun(normalizedText)));
2348
2349     return metrics;
2350 }
2351
2352 void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, float y, bool fill, std::optional<float> maxWidth)
2353 {
2354     auto& fontProxy = this->fontProxy();
2355     const auto& fontMetrics = fontProxy.fontMetrics();
2356
2357     auto* c = drawingContext();
2358     if (!c)
2359         return;
2360     if (!state().hasInvertibleTransform)
2361         return;
2362     if (!std::isfinite(x) | !std::isfinite(y))
2363         return;
2364     if (maxWidth && (!std::isfinite(maxWidth.value()) || maxWidth.value() <= 0))
2365         return;
2366
2367     // If gradient size is zero, then paint nothing.
2368     auto* gradient = c->strokeGradient();
2369     if (!fill && gradient && gradient->isZeroSize())
2370         return;
2371
2372     gradient = c->fillGradient();
2373     if (fill && gradient && gradient->isZeroSize())
2374         return;
2375
2376     String normalizedText = text;
2377     normalizeSpaces(normalizedText);
2378
2379     // FIXME: Need to turn off font smoothing.
2380
2381     const RenderStyle* computedStyle;
2382     auto direction = toTextDirection(state().direction, &computedStyle);
2383     bool isRTL = direction == RTL;
2384     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
2385
2386     TextRun textRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override, true);
2387     // Draw the item text at the correct point.
2388     FloatPoint location(x, y);
2389     switch (state().textBaseline) {
2390     case TopTextBaseline:
2391     case HangingTextBaseline:
2392         location.setY(y + fontMetrics.ascent());
2393         break;
2394     case BottomTextBaseline:
2395     case IdeographicTextBaseline:
2396         location.setY(y - fontMetrics.descent());
2397         break;
2398     case MiddleTextBaseline:
2399         location.setY(y - fontMetrics.descent() + fontMetrics.height() / 2);
2400         break;
2401     case AlphabeticTextBaseline:
2402     default:
2403          // Do nothing.
2404         break;
2405     }
2406
2407     float fontWidth = fontProxy.width(TextRun(normalizedText, 0, 0, AllowTrailingExpansion, direction, override));
2408
2409     bool useMaxWidth = maxWidth && maxWidth.value() < fontWidth;
2410     float width = useMaxWidth ? maxWidth.value() : fontWidth;
2411
2412     auto align = state().textAlign;
2413     if (align == StartTextAlign)
2414         align = isRTL ? RightTextAlign : LeftTextAlign;
2415     else if (align == EndTextAlign)
2416         align = isRTL ? LeftTextAlign : RightTextAlign;
2417
2418     switch (align) {
2419     case CenterTextAlign:
2420         location.setX(location.x() - width / 2);
2421         break;
2422     case RightTextAlign:
2423         location.setX(location.x() - width);
2424         break;
2425     default:
2426         break;
2427     }
2428
2429     // The slop built in to this mask rect matches the heuristic used in FontCGWin.cpp for GDI text.
2430     FloatRect textRect = FloatRect(location.x() - fontMetrics.height() / 2, location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),
2431         width + fontMetrics.height(), fontMetrics.lineSpacing());
2432     if (!fill)
2433         inflateStrokeRect(textRect);
2434
2435 #if USE(CG)
2436     const CanvasStyle& drawStyle = fill ? state().fillStyle : state().strokeStyle;
2437     if (drawStyle.canvasGradient() || drawStyle.canvasPattern()) {
2438         IntRect maskRect = enclosingIntRect(textRect);
2439
2440         // If we have a shadow, we need to draw it before the mask operation.
2441         // Follow a procedure similar to paintTextWithShadows in TextPainter.
2442
2443         if (shouldDrawShadows()) {
2444             GraphicsContextStateSaver stateSaver(*c);
2445
2446             FloatSize offset(0, 2 * maskRect.height());
2447
2448             FloatSize shadowOffset;
2449             float shadowRadius;
2450             Color shadowColor;
2451             c->getShadow(shadowOffset, shadowRadius, shadowColor);
2452
2453             FloatRect shadowRect(maskRect);
2454             shadowRect.inflate(shadowRadius * 1.4);
2455             shadowRect.move(shadowOffset * -1);
2456             c->clip(shadowRect);
2457
2458             shadowOffset += offset;
2459
2460             c->setLegacyShadow(shadowOffset, shadowRadius, shadowColor);
2461
2462             if (fill)
2463                 c->setFillColor(Color::black);
2464             else
2465                 c->setStrokeColor(Color::black);
2466
2467             fontProxy.drawBidiText(*c, textRun, location + offset, FontCascade::UseFallbackIfFontNotReady);
2468         }
2469
2470         auto maskImage = ImageBuffer::createCompatibleBuffer(maskRect.size(), ColorSpaceSRGB, *c);
2471         if (!maskImage)
2472             return;
2473
2474         auto& maskImageContext = maskImage->context();
2475
2476         if (fill)
2477             maskImageContext.setFillColor(Color::black);
2478         else {
2479             maskImageContext.setStrokeColor(Color::black);
2480             maskImageContext.setStrokeThickness(c->strokeThickness());
2481         }
2482
2483         maskImageContext.setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
2484
2485         if (useMaxWidth) {
2486             maskImageContext.translate(location.x() - maskRect.x(), location.y() - maskRect.y());
2487             // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
2488             maskImageContext.scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
2489             fontProxy.drawBidiText(maskImageContext, textRun, FloatPoint(0, 0), FontCascade::UseFallbackIfFontNotReady);
2490         } else {
2491             maskImageContext.translate(-maskRect.x(), -maskRect.y());
2492             fontProxy.drawBidiText(maskImageContext, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2493         }
2494
2495         GraphicsContextStateSaver stateSaver(*c);
2496         c->clipToImageBuffer(*maskImage, maskRect);
2497         drawStyle.applyFillColor(*c);
2498         c->fillRect(maskRect);
2499         return;
2500     }
2501 #endif
2502
2503     c->setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
2504
2505     GraphicsContextStateSaver stateSaver(*c);
2506     if (useMaxWidth) {
2507         c->translate(location.x(), location.y());
2508         // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
2509         c->scale(FloatSize((fontWidth > 0 ? (width / fontWidth) : 0), 1));
2510         location = FloatPoint();
2511     }
2512
2513     if (isFullCanvasCompositeMode(state().globalComposite)) {
2514         beginCompositeLayer();
2515         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2516         endCompositeLayer();
2517         didDrawEntireCanvas();
2518     } else if (state().globalComposite == CompositeCopy) {
2519         clearCanvas();
2520         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2521         didDrawEntireCanvas();
2522     } else {
2523         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
2524         didDraw(textRect);
2525     }
2526 }
2527
2528 void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
2529 {
2530     // Fast approximation of the stroke's bounding rect.
2531     // This yields a slightly oversized rect but is very fast
2532     // compared to Path::strokeBoundingRect().
2533     static const float root2 = sqrtf(2);
2534     float delta = state().lineWidth / 2;
2535     if (state().lineJoin == MiterJoin)
2536         delta *= state().miterLimit;
2537     else if (state().lineCap == SquareCap)
2538         delta *= root2;
2539     rect.inflate(delta);
2540 }
2541
2542 auto CanvasRenderingContext2D::fontProxy() -> const FontProxy&
2543 {
2544     canvas().document().updateStyleIfNeeded();
2545     if (!state().font.realized())
2546         setFont(state().unparsedFont);
2547     return state().font;
2548 }
2549
2550 #if ENABLE(ACCELERATED_2D_CANVAS)
2551
2552 PlatformLayer* CanvasRenderingContext2D::platformLayer() const
2553 {
2554     return canvas().buffer() ? canvas().buffer()->platformLayer() : nullptr;
2555 }
2556
2557 #endif
2558
2559 static inline InterpolationQuality smoothingToInterpolationQuality(CanvasRenderingContext2D::ImageSmoothingQuality quality)
2560 {
2561     switch (quality) {
2562     case CanvasRenderingContext2D::ImageSmoothingQuality::Low:
2563         return InterpolationLow;
2564     case CanvasRenderingContext2D::ImageSmoothingQuality::Medium:
2565         return InterpolationMedium;
2566     case CanvasRenderingContext2D::ImageSmoothingQuality::High:
2567         return InterpolationHigh;
2568     }
2569
2570     ASSERT_NOT_REACHED();
2571     return InterpolationLow;
2572 };
2573
2574 String CanvasRenderingContext2D::stringForImageSmoothingQuality(ImageSmoothingQuality imageSmoothingQuality)
2575 {
2576     switch (imageSmoothingQuality) {
2577     case ImageSmoothingQuality::Low:
2578         return ASCIILiteral("low");
2579     case ImageSmoothingQuality::Medium:
2580         return ASCIILiteral("medium");
2581     case ImageSmoothingQuality::High:
2582         return ASCIILiteral("high");
2583     }
2584
2585     ASSERT_NOT_REACHED();
2586     return String();
2587 }
2588
2589 auto CanvasRenderingContext2D::imageSmoothingQuality() const -> ImageSmoothingQuality
2590 {
2591     return state().imageSmoothingQuality;
2592 }
2593
2594 void CanvasRenderingContext2D::setImageSmoothingQuality(ImageSmoothingQuality quality)
2595 {
2596     if (quality == state().imageSmoothingQuality)
2597         return;
2598
2599     realizeSaves();
2600     modifiableState().imageSmoothingQuality = quality;
2601
2602     if (!state().imageSmoothingEnabled)
2603         return;
2604
2605     if (auto* context = drawingContext())
2606         context->setImageInterpolationQuality(smoothingToInterpolationQuality(quality));
2607 }
2608
2609 bool CanvasRenderingContext2D::imageSmoothingEnabled() const
2610 {
2611     return state().imageSmoothingEnabled;
2612 }
2613
2614 void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)
2615 {
2616     if (enabled == state().imageSmoothingEnabled)
2617         return;
2618
2619     realizeSaves();
2620     modifiableState().imageSmoothingEnabled = enabled;
2621     auto* c = drawingContext();
2622     if (c)
2623         c->setImageInterpolationQuality(enabled ? smoothingToInterpolationQuality(state().imageSmoothingQuality) : InterpolationNone);
2624 }
2625
2626 } // namespace WebCore