sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp - Issue 1001913003: Remove <canvas>

Unified Diff: sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp

Issue 1001913003: Remove <canvas> (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « sky/engine/core/html/canvas/CanvasRenderingContext2D.h ('k') | sky/engine/core/html/canvas/CanvasRenderingContext2D.idl » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp

diff --git a/sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp b/sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp

deleted file mode 100644

index a163b9a10e6fe8d6b4d9bbb6825ff71f4b2f99c2..0000000000000000000000000000000000000000

--- a/sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp

+++ /dev/null

@@ -1,2210 +0,0 @@

-/*

- *

- * Redistribution and use in source and binary forms, with or without

- * modification, are permitted provided that the following conditions

- * are met:

- * 1. Redistributions of source code must retain the above copyright

- * notice, this list of conditions and the following disclaimer.

- * 2. Redistributions in binary form must reproduce the above copyright

- * notice, this list of conditions and the following disclaimer in the

- * documentation and/or other materials provided with the distribution.

- *

- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR

- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

- */

-#include "sky/engine/config.h"

-#include "sky/engine/core/html/canvas/CanvasRenderingContext2D.h"

-#include "gen/sky/core/CSSPropertyNames.h"

-#include "sky/engine/bindings/exception_messages.h"

-#include "sky/engine/bindings/exception_state.h"

-#include "sky/engine/bindings/exception_state_placeholder.h"

-#include "sky/engine/core/css/CSSFontSelector.h"

-#include "sky/engine/core/css/StylePropertySet.h"

-#include "sky/engine/core/css/parser/BisonCSSParser.h"

-#include "sky/engine/core/css/resolver/StyleResolver.h"

-#include "sky/engine/core/dom/ExceptionCode.h"

-#include "sky/engine/core/dom/StyleEngine.h"

-#include "sky/engine/core/events/Event.h"

-#include "sky/engine/core/fetch/ImageResource.h"

-#include "sky/engine/core/frame/ImageBitmap.h"

-#include "sky/engine/core/html/HTMLCanvasElement.h"

-#include "sky/engine/core/html/HTMLImageElement.h"

-#include "sky/engine/core/html/ImageData.h"

-#include "sky/engine/core/html/TextMetrics.h"

-#include "sky/engine/core/html/canvas/CanvasGradient.h"

-#include "sky/engine/core/html/canvas/CanvasPattern.h"

-#include "sky/engine/core/html/canvas/CanvasStyle.h"

-#include "sky/engine/core/html/canvas/Path2D.h"

-#include "sky/engine/core/rendering/RenderImage.h"

-#include "sky/engine/core/rendering/RenderLayer.h"

-#include "sky/engine/core/rendering/RenderTheme.h"

-#include "sky/engine/platform/fonts/FontCache.h"

-#include "sky/engine/platform/geometry/FloatQuad.h"

-#include "sky/engine/platform/graphics/DrawLooperBuilder.h"

-#include "sky/engine/platform/graphics/GraphicsContextStateSaver.h"

-#include "sky/engine/platform/text/TextRun.h"

-#include "sky/engine/wtf/CheckedArithmetic.h"

-#include "sky/engine/wtf/MathExtras.h"

-#include "sky/engine/wtf/OwnPtr.h"

-#include "sky/engine/wtf/Uint8ClampedArray.h"

-#include "sky/engine/wtf/text/StringBuilder.h"

-namespace blink {

-static const int defaultFontSize = 10;

-static const char defaultFontFamily[] = "sans-serif";

-static const char defaultFont[] = "10px sans-serif";

-static const char inherit[] = "inherit";

-static const char rtl[] = "rtl";

-static const char ltr[] = "ltr";

-static const double TryRestoreContextInterval = 0.5;

-static const unsigned MaxTryRestoreContextAttempts = 4;

-static bool contextLostRestoredEventsEnabled()

- return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();

-CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, const Canvas2DContextAttributes* attrs)

- : CanvasRenderingContext(canvas)

- , m_isContextLost(false)

- , m_contextRestorable(true)

- , m_storageMode(!attrs ? PersistentStorage : attrs->parsedStorage())

- , m_tryRestoreContextAttemptCount(0)

- , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)

- , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)

- , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)

- m_stateStack.append(adoptPtr(new State()));

-void CanvasRenderingContext2D::unwindStateStack()

- if (size_t stackSize = m_stateStack.size()) {

- if (GraphicsContext* context = canvas()->existingDrawingContext()) {

- while (--stackSize)

- context->restore();

- }

-CanvasRenderingContext2D::~CanvasRenderingContext2D()

-void CanvasRenderingContext2D::validateStateStack()

-#if ENABLE(ASSERT)

- GraphicsContext* context = canvas()->existingDrawingContext();

- if (context && !context->contextDisabled())

- ASSERT(context->saveCount() == m_stateStack.size());

-#endif

-bool CanvasRenderingContext2D::isAccelerated() const

- if (!canvas()->hasImageBuffer())

- return false;

- GraphicsContext* context = drawingContext();

- return context && context->isAccelerated();

-bool CanvasRenderingContext2D::isContextLost() const

- return m_isContextLost;

-void CanvasRenderingContext2D::loseContext()

- if (m_isContextLost)

- return;

- m_isContextLost = true;

- m_dispatchContextLostEventTimer.startOneShot(0, FROM_HERE);

-void CanvasRenderingContext2D::restoreContext()

- if (!m_contextRestorable)

- return;

- // This code path is for restoring from an eviction

- // Restoring from surface failure is handled internally

- ASSERT(m_isContextLost && !canvas()->hasImageBuffer());

- if (canvas()->buffer()) {

- if (contextLostRestoredEventsEnabled()) {

- m_dispatchContextRestoredEventTimer.startOneShot(0, FROM_HERE);

- } else {

- // legacy synchronous context restoration.

- reset();

- m_isContextLost = false;

- }

-void CanvasRenderingContext2D::dispatchContextLostEvent(Timer<CanvasRenderingContext2D>*)

- if (contextLostRestoredEventsEnabled()) {

- RefPtr<Event> event = Event::createCancelable(EventTypeNames::contextlost);

- canvas()->dispatchEvent(event);

- if (event->defaultPrevented()) {

- m_contextRestorable = false;

- }

- // If an image buffer is present, it means the context was not lost due to

- // an eviction, but rather due to a surface failure (gpu context lost?)

- if (m_contextRestorable && canvas()->hasImageBuffer()) {

- m_tryRestoreContextAttemptCount = 0;

- m_tryRestoreContextEventTimer.startRepeating(TryRestoreContextInterval, FROM_HERE);

- }

-void CanvasRenderingContext2D::tryRestoreContextEvent(Timer<CanvasRenderingContext2D>* timer)

- if (!m_isContextLost) {

- // Canvas was already restored (possibly thanks to a resize), so stop trying.

- m_tryRestoreContextEventTimer.stop();

- return;

- }

- if (canvas()->hasImageBuffer() && canvas()->buffer()->restoreSurface()) {

- m_tryRestoreContextEventTimer.stop();

- dispatchContextRestoredEvent(0);

- }

- if (++m_tryRestoreContextAttemptCount > MaxTryRestoreContextAttempts)

- canvas()->discardImageBuffer();

- if (!canvas()->hasImageBuffer()) {

- // final attempt: allocate a brand new image buffer instead of restoring

- timer->stop();

- if (canvas()->buffer())

- dispatchContextRestoredEvent(0);

- }

-void CanvasRenderingContext2D::dispatchContextRestoredEvent(Timer<CanvasRenderingContext2D>*)

- if (!m_isContextLost)

- return;

- reset();

- m_isContextLost = false;

- if (contextLostRestoredEventsEnabled()) {

- RefPtr<Event> event(Event::create(EventTypeNames::contextrestored));

- canvas()->dispatchEvent(event);

- }

-void CanvasRenderingContext2D::reset()

- validateStateStack();

- unwindStateStack();

- m_stateStack.resize(1);

- m_stateStack.first() = adoptPtr(new State());

- m_path.clear();

- validateStateStack();

-// Important: Several of these properties are also stored in GraphicsContext's

-// StrokeData. The default values that StrokeData uses may not the same values

-// that the canvas 2d spec specifies. Make sure to sync the initial state of the

-// GraphicsContext in HTMLCanvasElement::createImageBuffer()!

-CanvasRenderingContext2D::State::State()

- : m_unrealizedSaveCount(0)

- , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))

- , m_fillStyle(CanvasStyle::createFromRGBA(Color::black))

- , m_lineWidth(1)

- , m_lineCap(ButtCap)

- , m_lineJoin(MiterJoin)

- , m_miterLimit(10)

- , m_shadowBlur(0)

- , m_shadowColor(Color::transparent)

- , m_invertibleCTM(true)

- , m_lineDashOffset(0)

- , m_imageSmoothingEnabled(true)

- , m_textAlign(StartTextAlign)

- , m_textBaseline(AlphabeticTextBaseline)

- , m_direction(DirectionInherit)

- , m_unparsedFont(defaultFont)

- , m_realizedFont(false)

- , m_hasClip(false)

-CanvasRenderingContext2D::State::State(const State& other)

- : CSSFontSelectorClient()

- , m_unrealizedSaveCount(other.m_unrealizedSaveCount)

- , m_unparsedStrokeColor(other.m_unparsedStrokeColor)

- , m_unparsedFillColor(other.m_unparsedFillColor)

- , m_strokeStyle(other.m_strokeStyle)

- , m_fillStyle(other.m_fillStyle)

- , m_lineWidth(other.m_lineWidth)

- , m_lineCap(other.m_lineCap)

- , m_lineJoin(other.m_lineJoin)

- , m_miterLimit(other.m_miterLimit)

- , m_shadowOffset(other.m_shadowOffset)

- , m_shadowBlur(other.m_shadowBlur)

- , m_shadowColor(other.m_shadowColor)

- , m_transform(other.m_transform)

- , m_invertibleCTM(other.m_invertibleCTM)

- , m_lineDashOffset(other.m_lineDashOffset)

- , m_imageSmoothingEnabled(other.m_imageSmoothingEnabled)

- , m_textAlign(other.m_textAlign)

- , m_textBaseline(other.m_textBaseline)

- , m_direction(other.m_direction)

- , m_unparsedFont(other.m_unparsedFont)

- , m_font(other.m_font)

- , m_realizedFont(other.m_realizedFont)

- , m_hasClip(other.m_hasClip)

- if (m_realizedFont)

- static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);

-CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other)

- if (this == &other)

- return *this;

-#if !ENABLE(OILPAN)

- if (m_realizedFont)

- static_cast<CSSFontSelector*>(m_font.fontSelector())->unregisterForInvalidationCallbacks(this);

-#endif

- m_unrealizedSaveCount = other.m_unrealizedSaveCount;

- m_unparsedStrokeColor = other.m_unparsedStrokeColor;

- m_unparsedFillColor = other.m_unparsedFillColor;

- m_strokeStyle = other.m_strokeStyle;

- m_fillStyle = other.m_fillStyle;

- m_lineWidth = other.m_lineWidth;

- m_lineCap = other.m_lineCap;

- m_lineJoin = other.m_lineJoin;

- m_miterLimit = other.m_miterLimit;

- m_shadowOffset = other.m_shadowOffset;

- m_shadowBlur = other.m_shadowBlur;

- m_shadowColor = other.m_shadowColor;

- m_transform = other.m_transform;

- m_invertibleCTM = other.m_invertibleCTM;

- m_imageSmoothingEnabled = other.m_imageSmoothingEnabled;

- m_textAlign = other.m_textAlign;

- m_textBaseline = other.m_textBaseline;

- m_direction = other.m_direction;

- m_unparsedFont = other.m_unparsedFont;

- m_font = other.m_font;

- m_realizedFont = other.m_realizedFont;

- m_hasClip = other.m_hasClip;

- if (m_realizedFont)

- static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);

- return *this;

-CanvasRenderingContext2D::State::~State()

-#if !ENABLE(OILPAN)

- if (m_realizedFont)

- static_cast<CSSFontSelector*>(m_font.fontSelector())->unregisterForInvalidationCallbacks(this);

-#endif

-void CanvasRenderingContext2D::State::fontsNeedUpdate(CSSFontSelector* fontSelector)

- ASSERT_ARG(fontSelector, fontSelector == m_font.fontSelector());

- ASSERT(m_realizedFont);

- m_font.update(fontSelector);

-void CanvasRenderingContext2D::realizeSaves(GraphicsContext* context)

- validateStateStack();

- if (state().m_unrealizedSaveCount) {

- ASSERT(m_stateStack.size() >= 1);

- // Reduce the current state's unrealized count by one now,

- // to reflect the fact we are saving one state.

- m_stateStack.last()->m_unrealizedSaveCount--;

- m_stateStack.append(adoptPtr(new State(state())));

- // Set the new state's unrealized count to 0, because it has no outstanding saves.

- // We need to do this explicitly because the copy constructor and operator= used

- // by the Vector operations copy the unrealized count from the previous state (in

- // turn necessary to support correct resizing and unwinding of the stack).

- m_stateStack.last()->m_unrealizedSaveCount = 0;

- if (!context)

- context = drawingContext();

- if (context)

- context->save();

- validateStateStack();

- }

-void CanvasRenderingContext2D::restore()

- validateStateStack();

- if (state().m_unrealizedSaveCount) {

- // We never realized the save, so just record that it was unnecessary.

- --m_stateStack.last()->m_unrealizedSaveCount;

- return;

- }

- ASSERT(m_stateStack.size() >= 1);

- if (m_stateStack.size() <= 1)

- return;

- m_path.transform(state().m_transform);

- m_stateStack.removeLast();

- m_path.transform(state().m_transform.inverse());

- GraphicsContext* c = drawingContext();

- if (c)

- c->restore();

- validateStateStack();

-CanvasStyle* CanvasRenderingContext2D::strokeStyle() const

- return state().m_strokeStyle.get();

-void CanvasRenderingContext2D::setStrokeStyle(PassRefPtr<CanvasStyle> prpStyle)

- RefPtr<CanvasStyle> style = prpStyle;

- if (!style)

- return;

- if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentColor(*style))

- return;

- if (style->isCurrentColor()) {

- if (style->hasOverrideAlpha())

- style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));

- else

- style = CanvasStyle::createFromRGBA(currentColor(canvas()));

- }

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_strokeStyle = style.release();

- if (!c)

- return;

- state().m_strokeStyle->applyStrokeColor(c);

- modifiableState().m_unparsedStrokeColor = String();

-CanvasStyle* CanvasRenderingContext2D::fillStyle() const

- return state().m_fillStyle.get();

-void CanvasRenderingContext2D::setFillStyle(PassRefPtr<CanvasStyle> prpStyle)

- RefPtr<CanvasStyle> style = prpStyle;

- if (!style)

- return;

- if (state().m_fillStyle && state().m_fillStyle->isEquivalentColor(*style))

- return;

- if (style->isCurrentColor()) {

- if (style->hasOverrideAlpha())

- style = CanvasStyle::createFromRGBA(colorWithOverrideAlpha(currentColor(canvas()), style->overrideAlpha()));

- else

- style = CanvasStyle::createFromRGBA(currentColor(canvas()));

- }

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_fillStyle = style.release();

- if (!c)

- return;

- state().m_fillStyle->applyFillColor(c);

- modifiableState().m_unparsedFillColor = String();

-float CanvasRenderingContext2D::lineWidth() const

- return state().m_lineWidth;

-void CanvasRenderingContext2D::setLineWidth(float width)

- if (!(std::isfinite(width) && width > 0))

- return;

- if (state().m_lineWidth == width)

- return;

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_lineWidth = width;

- if (!c)

- return;

- c->setStrokeThickness(width);

-String CanvasRenderingContext2D::lineCap() const

- return lineCapName(state().m_lineCap);

-void CanvasRenderingContext2D::setLineCap(const String& s)

- LineCap cap;

- if (!parseLineCap(s, cap))

- return;

- if (state().m_lineCap == cap)

- return;

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_lineCap = cap;

- if (!c)

- return;

- c->setLineCap(cap);

-String CanvasRenderingContext2D::lineJoin() const

- return lineJoinName(state().m_lineJoin);

-void CanvasRenderingContext2D::setLineJoin(const String& s)

- LineJoin join;

- if (!parseLineJoin(s, join))

- return;

- if (state().m_lineJoin == join)

- return;

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_lineJoin = join;

- if (!c)

- return;

- c->setLineJoin(join);

-float CanvasRenderingContext2D::miterLimit() const

- return state().m_miterLimit;

-void CanvasRenderingContext2D::setMiterLimit(float limit)

- if (!(std::isfinite(limit) && limit > 0))

- return;

- if (state().m_miterLimit == limit)

- return;

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_miterLimit = limit;

- if (!c)

- return;

- c->setMiterLimit(limit);

-float CanvasRenderingContext2D::shadowOffsetX() const

- return state().m_shadowOffset.width();

-void CanvasRenderingContext2D::setShadowOffsetX(float x)

- if (!std::isfinite(x))

- return;

- if (state().m_shadowOffset.width() == x)

- return;

- realizeSaves(0);

- modifiableState().m_shadowOffset.setWidth(x);

- applyShadow();

-float CanvasRenderingContext2D::shadowOffsetY() const

- return state().m_shadowOffset.height();

-void CanvasRenderingContext2D::setShadowOffsetY(float y)

- if (!std::isfinite(y))

- return;

- if (state().m_shadowOffset.height() == y)

- return;

- realizeSaves(0);

- modifiableState().m_shadowOffset.setHeight(y);

- applyShadow();

-float CanvasRenderingContext2D::shadowBlur() const

- return state().m_shadowBlur;

-void CanvasRenderingContext2D::setShadowBlur(float blur)

- if (!(std::isfinite(blur) && blur >= 0))

- return;

- if (state().m_shadowBlur == blur)

- return;

- realizeSaves(0);

- modifiableState().m_shadowBlur = blur;

- applyShadow();

-String CanvasRenderingContext2D::shadowColor() const

- return Color(state().m_shadowColor).serialized();

-void CanvasRenderingContext2D::setShadowColor(const String& color)

- RGBA32 rgba;

- if (!parseColorOrCurrentColor(rgba, color, canvas()))

- return;

- if (state().m_shadowColor == rgba)

- return;

- realizeSaves(0);

- modifiableState().m_shadowColor = rgba;

- applyShadow();

-const Vector<float>& CanvasRenderingContext2D::getLineDash() const

- return state().m_lineDash;

-static bool lineDashSequenceIsValid(const Vector<float>& dash)

- for (size_t i = 0; i < dash.size(); i++) {

- if (!std::isfinite(dash[i]) || dash[i] < 0)

- return false;

- }

- return true;

-void CanvasRenderingContext2D::setLineDash(const Vector<float>& dash)

- if (!lineDashSequenceIsValid(dash))

- return;

- realizeSaves(0);

- modifiableState().m_lineDash = dash;

- // Spec requires the concatenation of two copies the dash list when the

- // number of elements is odd

- if (dash.size() % 2)

- modifiableState().m_lineDash.appendVector(dash);

- applyLineDash();

-float CanvasRenderingContext2D::lineDashOffset() const

- return state().m_lineDashOffset;

-void CanvasRenderingContext2D::setLineDashOffset(float offset)

- if (!std::isfinite(offset) || state().m_lineDashOffset == offset)

- return;

- realizeSaves(0);

- modifiableState().m_lineDashOffset = offset;

- applyLineDash();

-void CanvasRenderingContext2D::applyLineDash() const

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- DashArray convertedLineDash(state().m_lineDash.size());

- for (size_t i = 0; i < state().m_lineDash.size(); ++i)

- convertedLineDash[i] = static_cast<DashArrayElement>(state().m_lineDash[i]);

- c->setLineDash(convertedLineDash, state().m_lineDashOffset);

-void CanvasRenderingContext2D::scale(float sx, float sy)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- if (!std::isfinite(sx) | !std::isfinite(sy))

- return;

- AffineTransform newTransform = state().m_transform;

- newTransform.scaleNonUniform(sx, sy);

- if (state().m_transform == newTransform)

- return;

- realizeSaves(c);

- if (!newTransform.isInvertible()) {

- modifiableState().m_invertibleCTM = false;

- return;

- }

- modifiableState().m_transform = newTransform;

- c->scale(sx, sy);

- m_path.transform(AffineTransform().scaleNonUniform(1.0 / sx, 1.0 / sy));

-void CanvasRenderingContext2D::rotate(float angleInRadians)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- if (!std::isfinite(angleInRadians))

- return;

- AffineTransform newTransform = state().m_transform;

- newTransform.rotateRadians(angleInRadians);

- if (state().m_transform == newTransform)

- return;

- realizeSaves(c);

- if (!newTransform.isInvertible()) {

- modifiableState().m_invertibleCTM = false;

- return;

- }

- modifiableState().m_transform = newTransform;

- c->rotate(angleInRadians);

- m_path.transform(AffineTransform().rotateRadians(-angleInRadians));

-void CanvasRenderingContext2D::translate(float tx, float ty)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- if (!std::isfinite(tx) | !std::isfinite(ty))

- return;

- AffineTransform newTransform = state().m_transform;

- newTransform.translate(tx, ty);

- if (state().m_transform == newTransform)

- return;

- realizeSaves(c);

- if (!newTransform.isInvertible()) {

- modifiableState().m_invertibleCTM = false;

- return;

- }

- modifiableState().m_transform = newTransform;

- c->translate(tx, ty);

- m_path.transform(AffineTransform().translate(-tx, -ty));

-void CanvasRenderingContext2D::transform(float m11, float m12, float m21, float m22, float dx, float dy)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- return;

- AffineTransform transform(m11, m12, m21, m22, dx, dy);

- AffineTransform newTransform = state().m_transform * transform;

- if (state().m_transform == newTransform)

- return;

- realizeSaves(c);

- modifiableState().m_transform = newTransform;

- if (!newTransform.isInvertible()) {

- modifiableState().m_invertibleCTM = false;

- return;

- }

- c->concatCTM(transform);

- m_path.transform(transform.inverse());

-void CanvasRenderingContext2D::resetTransform()

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- AffineTransform ctm = state().m_transform;

- bool invertibleCTM = state().m_invertibleCTM;

- // It is possible that CTM is identity while CTM is not invertible.

- // When CTM becomes non-invertible, realizeSaves() can make CTM identity.

- if (ctm.isIdentity() && invertibleCTM)

- return;

- realizeSaves(c);

- // resetTransform() resolves the non-invertible CTM state.

- modifiableState().m_transform.makeIdentity();

- modifiableState().m_invertibleCTM = true;

- c->setCTM(canvas()->baseTransform());

- if (invertibleCTM)

- m_path.transform(ctm);

- // When else, do nothing because all transform methods didn't update m_path when CTM became non-invertible.

- // It means that resetTransform() restores m_path just before CTM became non-invertible.

-void CanvasRenderingContext2D::setTransform(float m11, float m12, float m21, float m22, float dx, float dy)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- return;

- resetTransform();

- transform(m11, m12, m21, m22, dx, dy);

-String CanvasRenderingContext2D::strokeColor()

- return strokeStyle()->color();

-void CanvasRenderingContext2D::setStrokeColor(const String& color)

- if (color == state().m_unparsedStrokeColor)

- return;

- realizeSaves(0);

- setStrokeStyle(CanvasStyle::createFromString(color));

- modifiableState().m_unparsedStrokeColor = color;

-void CanvasRenderingContext2D::setStrokeColor(float grayLevel)

- if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))

- return;

- setStrokeStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));

-void CanvasRenderingContext2D::setStrokeColor(const String& color, float alpha)

- setStrokeStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));

-void CanvasRenderingContext2D::setStrokeColor(float grayLevel, float alpha)

- if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))

- return;

- setStrokeStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, alpha));

-void CanvasRenderingContext2D::setStrokeColor(float r, float g, float b, float a)

- if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentRGBA(r, g, b, a))

- return;

- setStrokeStyle(CanvasStyle::createFromRGBAChannels(r, g, b, a));

-void CanvasRenderingContext2D::setStrokeColor(float c, float m, float y, float k, float a)

- if (state().m_strokeStyle && state().m_strokeStyle->isEquivalentCMYKA(c, m, y, k, a))

- return;

- setStrokeStyle(CanvasStyle::createFromCMYKAChannels(c, m, y, k, a));

-String CanvasRenderingContext2D::fillColor()

- return fillStyle()->color();

-void CanvasRenderingContext2D::setFillColor(const String& color)

- if (color == state().m_unparsedFillColor)

- return;

- realizeSaves(0);

- setFillStyle(CanvasStyle::createFromString(color));

- modifiableState().m_unparsedFillColor = color;

-void CanvasRenderingContext2D::setFillColor(float grayLevel)

- if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, 1.0f))

- return;

- setFillStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, 1.0f));

-void CanvasRenderingContext2D::setFillColor(const String& color, float alpha)

- setFillStyle(CanvasStyle::createFromStringWithOverrideAlpha(color, alpha));

-void CanvasRenderingContext2D::setFillColor(float grayLevel, float alpha)

- if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))

- return;

- setFillStyle(CanvasStyle::createFromGrayLevelWithAlpha(grayLevel, alpha));

-void CanvasRenderingContext2D::setFillColor(float r, float g, float b, float a)

- if (state().m_fillStyle && state().m_fillStyle->isEquivalentRGBA(r, g, b, a))

- return;

- setFillStyle(CanvasStyle::createFromRGBAChannels(r, g, b, a));

-void CanvasRenderingContext2D::setFillColor(float c, float m, float y, float k, float a)

- if (state().m_fillStyle && state().m_fillStyle->isEquivalentCMYKA(c, m, y, k, a))

- return;

- setFillStyle(CanvasStyle::createFromCMYKAChannels(c, m, y, k, a));

-void CanvasRenderingContext2D::beginPath()

- m_path.clear();

-static bool validateRectForCanvas(float& x, float& y, float& width, float& height)

- if (!std::isfinite(x) | !std::isfinite(y) | !std::isfinite(width) | !std::isfinite(height))

- return false;

- if (!width && !height)

- return false;

- if (width < 0) {

- width = -width;

- x -= width;

- }

- if (height < 0) {

- height = -height;

- y -= height;

- }

- return true;

-static WindRule parseWinding(const String& windingRuleString)

- if (windingRuleString == "nonzero")

- return RULE_NONZERO;

- if (windingRuleString == "evenodd")

- return RULE_EVENODD;

- ASSERT_NOT_REACHED();

- return RULE_EVENODD;

-void CanvasRenderingContext2D::fillInternal(const Path& path, const String& windingRuleString)

- if (path.isEmpty()) {

- return;

- }

- GraphicsContext* c = drawingContext();

- if (!c) {

- return;

- }

- if (!state().m_invertibleCTM) {

- return;

- }

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds)) {

- return;

- }

- // If gradient size is zero, then paint nothing.

- Gradient* gradient = c->fillGradient();

- if (gradient && gradient->isZeroSize()) {

- return;

- }

- WindRule windRule = c->fillRule();

- c->setFillRule(parseWinding(windingRuleString));

- FloatRect dirtyRect;

- if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {

- c->fillPath(path);

- didDraw(dirtyRect);

- }

- c->setFillRule(windRule);

-void CanvasRenderingContext2D::fill(const String& windingRuleString)

- fillInternal(m_path, windingRuleString);

-void CanvasRenderingContext2D::fill(Path2D* domPath, const String& windingRuleString)

- fillInternal(domPath->path(), windingRuleString);

-void CanvasRenderingContext2D::strokeInternal(const Path& path)

- if (path.isEmpty()) {

- return;

- }

- GraphicsContext* c = drawingContext();

- if (!c) {

- return;

- }

- if (!state().m_invertibleCTM) {

- return;

- }

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds))

- return;

- // If gradient size is zero, then paint nothing.

- Gradient* gradient = c->strokeGradient();

- if (gradient && gradient->isZeroSize()) {

- return;

- }

- FloatRect bounds = path.boundingRect();

- inflateStrokeRect(bounds);

- FloatRect dirtyRect;

- if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {

- c->strokePath(path);

- didDraw(dirtyRect);

- }

-void CanvasRenderingContext2D::stroke()

- strokeInternal(m_path);

-void CanvasRenderingContext2D::stroke(Path2D* domPath)

- strokeInternal(domPath->path());

-void CanvasRenderingContext2D::clipInternal(const Path& path, const String& windingRuleString)

- GraphicsContext* c = drawingContext();

- if (!c) {

- return;

- }

- if (!state().m_invertibleCTM) {

- return;

- }

- realizeSaves(c);

- c->canvasClip(path, parseWinding(windingRuleString));

- modifiableState().m_hasClip = true;

-void CanvasRenderingContext2D::clip(const String& windingRuleString)

- clipInternal(m_path, windingRuleString);

-void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString)

- clipInternal(domPath->path(), windingRuleString);

-bool CanvasRenderingContext2D::isPointInPath(const float x, const float y, const String& windingRuleString)

- return isPointInPathInternal(m_path, x, y, windingRuleString);

-bool CanvasRenderingContext2D::isPointInPath(Path2D* domPath, const float x, const float y, const String& windingRuleString)

- return isPointInPathInternal(domPath->path(), x, y, windingRuleString);

-bool CanvasRenderingContext2D::isPointInPathInternal(const Path& path, const float x, const float y, const String& windingRuleString)

- GraphicsContext* c = drawingContext();

- if (!c)

- return false;

- if (!state().m_invertibleCTM)

- return false;

- FloatPoint point(x, y);

- AffineTransform ctm = state().m_transform;

- FloatPoint transformedPoint = ctm.inverse().mapPoint(point);

- if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))

- return false;

- return path.contains(transformedPoint, parseWinding(windingRuleString));

-bool CanvasRenderingContext2D::isPointInStroke(const float x, const float y)

- return isPointInStrokeInternal(m_path, x, y);

-bool CanvasRenderingContext2D::isPointInStroke(Path2D* domPath, const float x, const float y)

- return isPointInStrokeInternal(domPath->path(), x, y);

-bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const float x, const float y)

- GraphicsContext* c = drawingContext();

- if (!c)

- return false;

- if (!state().m_invertibleCTM)

- return false;

- FloatPoint point(x, y);

- AffineTransform ctm = state().m_transform;

- FloatPoint transformedPoint = ctm.inverse().mapPoint(point);

- if (!std::isfinite(transformedPoint.x()) || !std::isfinite(transformedPoint.y()))

- return false;

- StrokeData strokeData;

- strokeData.setThickness(lineWidth());

- strokeData.setLineCap(getLineCap());

- strokeData.setLineJoin(getLineJoin());

- strokeData.setMiterLimit(miterLimit());

- strokeData.setLineDash(getLineDash(), lineDashOffset());

- return path.strokeContains(transformedPoint, strokeData);

-void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)

- if (!validateRectForCanvas(x, y, width, height))

- return;

- GraphicsContext* context = drawingContext();

- if (!context)

- return;

- if (!state().m_invertibleCTM)

- return;

- FloatRect rect(x, y, width, height);

- FloatRect dirtyRect;

- if (!computeDirtyRect(rect, &dirtyRect))

- return;

- bool saved = false;

- if (shouldDrawShadows()) {

- context->save();

- saved = true;

- context->clearShadow();

- }

- context->clearRect(rect);

- if (m_hitRegionManager)

- m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);

- if (saved)

- context->restore();

- validateStateStack();

- didDraw(dirtyRect);

-void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)

- if (!validateRectForCanvas(x, y, width, height))

- return;

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds))

- return;

- // from the HTML5 Canvas spec:

- // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing

- // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing

- Gradient* gradient = c->fillGradient();

- if (gradient && gradient->isZeroSize())

- return;

- FloatRect rect(x, y, width, height);

- if (rectContainsTransformedRect(rect, clipBounds)) {

- c->fillRect(rect);

- didDraw(clipBounds);

- } else {

- FloatRect dirtyRect;

- if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {

- c->fillRect(rect);

- didDraw(dirtyRect);

- }

-void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)

- if (!validateRectForCanvas(x, y, width, height))

- return;

- if (!(state().m_lineWidth >= 0))

- return;

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds))

- return;

- // If gradient size is zero, then paint nothing.

- Gradient* gradient = c->strokeGradient();

- if (gradient && gradient->isZeroSize())

- return;

- FloatRect rect(x, y, width, height);

- FloatRect boundingRect = rect;

- boundingRect.inflate(state().m_lineWidth / 2);

- FloatRect dirtyRect;

- if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {

- c->strokeRect(rect);

- didDraw(dirtyRect);

- }

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur)

- setShadow(FloatSize(width, height), blur, Color::transparent);

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color)

- RGBA32 rgba;

- if (!parseColorOrCurrentColor(rgba, color, canvas()))

- return;

- setShadow(FloatSize(width, height), blur, rgba);

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel)

- setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, 1));

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color, float alpha)

- RGBA32 rgba;

- if (!parseColorOrCurrentColor(rgba, color, canvas()))

- return;

- setShadow(FloatSize(width, height), blur, colorWithOverrideAlpha(rgba, alpha));

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float grayLevel, float alpha)

- setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, alpha));

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float r, float g, float b, float a)

- setShadow(FloatSize(width, height), blur, makeRGBA32FromFloats(r, g, b, a));

-void CanvasRenderingContext2D::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)

- setShadow(FloatSize(width, height), blur, makeRGBAFromCMYKA(c, m, y, k, a));

-void CanvasRenderingContext2D::clearShadow()

- setShadow(FloatSize(), 0, Color::transparent);

-void CanvasRenderingContext2D::setShadow(const FloatSize& offset, float blur, RGBA32 color)

- if (state().m_shadowOffset == offset && state().m_shadowBlur == blur && state().m_shadowColor == color)

- return;

- bool wasDrawingShadows = shouldDrawShadows();

- realizeSaves(0);

- modifiableState().m_shadowOffset = offset;

- modifiableState().m_shadowBlur = blur;

- modifiableState().m_shadowColor = color;

- if (!wasDrawingShadows && !shouldDrawShadows())

- return;

- applyShadow();

-void CanvasRenderingContext2D::applyShadow()

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (shouldDrawShadows()) {

- c->setShadow(state().m_shadowOffset, state().m_shadowBlur, state().m_shadowColor,

- DrawLooperBuilder::ShadowIgnoresTransforms);

- } else {

- c->clearShadow();

- }

-bool CanvasRenderingContext2D::shouldDrawShadows() const

- return alphaChannel(state().m_shadowColor) && (state().m_shadowBlur || !state().m_shadowOffset.isZero());

-static inline FloatRect normalizeRect(const FloatRect& rect)

- return FloatRect(std::min(rect.x(), rect.maxX()),

- std::min(rect.y(), rect.maxY()),

- std::max(rect.width(), -rect.width()),

- std::max(rect.height(), -rect.height()));

-static inline void clipRectsToImageRect(const FloatRect& imageRect, FloatRect* srcRect, FloatRect* dstRect)

- if (imageRect.contains(*srcRect))

- return;

- // Compute the src to dst transform

- FloatSize scale(dstRect->size().width() / srcRect->size().width(), dstRect->size().height() / srcRect->size().height());

- FloatPoint scaledSrcLocation = srcRect->location();

- scaledSrcLocation.scale(scale.width(), scale.height());

- FloatSize offset = dstRect->location() - scaledSrcLocation;

- srcRect->intersect(imageRect);

- // To clip the destination rectangle in the same proportion, transform the clipped src rect

- *dstRect = *srcRect;

- dstRect->scale(scale.width(), scale.height());

- dstRect->move(offset);

-void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource, float x, float y, ExceptionState& exceptionState)

- FloatSize destRectSize = imageSource->defaultDestinationSize();

- drawImage(imageSource, x, y, destRectSize.width(), destRectSize.height(), exceptionState);

-void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,

- float x, float y, float width, float height, ExceptionState& exceptionState)

- FloatSize sourceRectSize = imageSource->sourceSize();

- drawImage(imageSource, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);

-void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,

- float sx, float sy, float sw, float sh,

- float dx, float dy, float dw, float dh, ExceptionState& exceptionState)

- GraphicsContext* c = drawingContext(); // Do not exit yet if !c because we may need to throw exceptions first

- CompositeOperator op = c ? c->compositeOperation() : CompositeSourceOver;

- blink::WebBlendMode blendMode = c ? c->blendModeOperation() : blink::WebBlendModeNormal;

- drawImageInternal(imageSource, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState, op, blendMode, c);

-void CanvasRenderingContext2D::drawImageInternal(CanvasImageSource* imageSource,

- float sx, float sy, float sw, float sh,

- float dx, float dy, float dw, float dh, ExceptionState& exceptionState,

- CompositeOperator op, blink::WebBlendMode blendMode, GraphicsContext* c)

- RefPtr<Image> image;

- SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;

- if (!imageSource->isVideoElement()) {

- SourceImageMode mode = canvas() == imageSource ? CopySourceImageIfVolatile : DontCopySourceImage; // Thunking for ==

- image = imageSource->getSourceImageForCanvas(mode, &sourceImageStatus);

- if (sourceImageStatus == UndecodableSourceImageStatus)

- exceptionState.ThrowDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");

- if (!image || !image->width() || !image->height())

- return;

- }

- if (!c)

- c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dw) || !std::isfinite(dh)

- || !std::isfinite(sx) || !std::isfinite(sy) || !std::isfinite(sw) || !std::isfinite(sh)

- || !dw || !dh || !sw || !sh)

- return;

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds))

- return;

- FloatRect srcRect = normalizeRect(FloatRect(sx, sy, sw, sh));

- FloatRect dstRect = normalizeRect(FloatRect(dx, dy, dw, dh));

- clipRectsToImageRect(FloatRect(FloatPoint(), imageSource->sourceSize()), &srcRect, &dstRect);

- imageSource->adjustDrawRects(&srcRect, &dstRect);

- if (srcRect.isEmpty())

- return;

- FloatRect dirtyRect = clipBounds;

- if (rectContainsTransformedRect(dstRect, clipBounds)) {

- c->drawImage(image.get(), dstRect, srcRect, op, blendMode);

- } else {

- FloatRect dirtyRect;

- computeDirtyRect(dstRect, clipBounds, &dirtyRect);

- c->drawImage(image.get(), dstRect, srcRect, op, blendMode);

- }

- if (sourceImageStatus == ExternalSourceImageStatus && isAccelerated() && canvas()->buffer())

- canvas()->buffer()->flush();

- didDraw(dirtyRect);

-void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,

- float sx, float sy, float sw, float sh,

- float dx, float dy, float dw, float dh,

- const String& compositeOperation)

- if (!image)

- return;

- CompositeOperator op;

- blink::WebBlendMode blendOp = blink::WebBlendModeNormal;

- if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != blink::WebBlendModeNormal)

- op = CompositeSourceOver;

- drawImageInternal(image, sx, sy, sw, sh, dx, dy, dw, dh, IGNORE_EXCEPTION, op, blendOp);

-void CanvasRenderingContext2D::clearCanvas()

- FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- c->save();

- c->setCTM(canvas()->baseTransform());

- c->clearRect(canvasRect);

- c->restore();

-bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const FloatRect& transformedRect) const

- FloatQuad quad(rect);

- FloatQuad transformedQuad(transformedRect);

- return state().m_transform.mapQuad(quad).containsQuad(transformedQuad);

-PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)

- RefPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));

- return gradient.release();

-PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState& exceptionState)

- if (r0 < 0 || r1 < 0) {

- exceptionState.ThrowDOMException(IndexSizeError, String::format("The %s provided is less than 0.", r0 < 0 ? "r0" : "r1"));

- return nullptr;

- }

- RefPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);

- return gradient.release();

-PassRefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(CanvasImageSource* imageSource,

- const String& repetitionType, ExceptionState& exceptionState)

- Pattern::RepeatMode repeatMode = CanvasPattern::parseRepetitionType(repetitionType, exceptionState);

- if (exceptionState.had_exception())

- return nullptr;

- SourceImageStatus status;

- RefPtr<Image> imageForRendering = imageSource->getSourceImageForCanvas(CopySourceImageIfVolatile, &status);

- switch (status) {

- case NormalSourceImageStatus:

- break;

- case ZeroSizeCanvasSourceImageStatus:

- exceptionState.ThrowDOMException(InvalidStateError, String::format("The canvas %s is 0.", imageSource->sourceSize().width() ? "height" : "width"));

- return nullptr;

- case UndecodableSourceImageStatus:

- exceptionState.ThrowDOMException(InvalidStateError, "Source image is in the 'broken' state.");

- return nullptr;

- case InvalidSourceImageStatus:

- imageForRendering = Image::nullImage();

- break;

- case IncompleteSourceImageStatus:

- return nullptr;

- default:

- case ExternalSourceImageStatus: // should not happen when mode is CopySourceImageIfVolatile

- ASSERT_NOT_REACHED();

- return nullptr;

- }

- ASSERT(imageForRendering);

- return CanvasPattern::create(imageForRendering.release(), repeatMode);

-bool CanvasRenderingContext2D::computeDirtyRect(const FloatRect& localRect, FloatRect* dirtyRect)

- FloatRect clipBounds;

- if (!drawingContext()->getTransformedClipBounds(&clipBounds))

- return false;

- return computeDirtyRect(localRect, clipBounds, dirtyRect);

-bool CanvasRenderingContext2D::computeDirtyRect(const FloatRect& localRect, const FloatRect& transformedClipBounds, FloatRect* dirtyRect)

- FloatRect canvasRect = state().m_transform.mapRect(localRect);

- if (alphaChannel(state().m_shadowColor)) {

- FloatRect shadowRect(canvasRect);

- shadowRect.move(state().m_shadowOffset);

- shadowRect.inflate(state().m_shadowBlur);

- canvasRect.unite(shadowRect);

- }

- canvasRect.intersect(transformedClipBounds);

- if (canvasRect.isEmpty())

- return false;

- if (dirtyRect)

- *dirtyRect = canvasRect;

- return true;

-void CanvasRenderingContext2D::didDraw(const FloatRect& dirtyRect)

- if (dirtyRect.isEmpty())

- return;

- canvas()->didDraw(dirtyRect);

-GraphicsContext* CanvasRenderingContext2D::drawingContext() const

- if (isContextLost())

- return 0;

- return canvas()->drawingContext();

-static PassRefPtr<ImageData> createEmptyImageData(const IntSize& size)

- if (RefPtr<ImageData> data = ImageData::create(size)) {

- data->data()->zeroFill();

- return data.release();

- }

- return nullptr;

-PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(PassRefPtr<ImageData> imageData) const

- return createEmptyImageData(imageData->size());

-PassRefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionState& exceptionState) const

- if (!sw || !sh) {

- exceptionState.ThrowDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));

- return nullptr;

- }

- FloatSize logicalSize(fabs(sw), fabs(sh));

- if (!logicalSize.isExpressibleAsIntSize())

- return nullptr;

- IntSize size = expandedIntSize(logicalSize);

- if (size.width() < 1)

- size.setWidth(1);

- if (size.height() < 1)

- size.setHeight(1);

- return createEmptyImageData(size);

-PassRefPtr<ImageData> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh, ExceptionState& exceptionState) const

- if (!sw || !sh)

- exceptionState.ThrowDOMException(IndexSizeError, String::format("The source %s is 0.", sw ? "height" : "width"));

- if (exceptionState.had_exception())

- return nullptr;

- if (sw < 0) {

- sx += sw;

- sw = -sw;

- }

- if (sh < 0) {

- sy += sh;

- sh = -sh;

- }

- FloatRect logicalRect(sx, sy, sw, sh);

- if (logicalRect.width() < 1)

- logicalRect.setWidth(1);

- if (logicalRect.height() < 1)

- logicalRect.setHeight(1);

- if (!logicalRect.isExpressibleAsIntRect())

- return nullptr;

- IntRect imageDataRect = enclosingIntRect(logicalRect);

- ImageBuffer* buffer = canvas()->buffer();

- if (!buffer || isContextLost())

- return createEmptyImageData(imageDataRect.size());

- RefPtr<Uint8ClampedArray> byteArray = buffer->getImageData(Unmultiplied, imageDataRect);

- if (!byteArray)

- return nullptr;

- return ImageData::create(imageDataRect.size(), byteArray.release());

-void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy)

- putImageData(data, dx, dy, 0, 0, data->width(), data->height());

-void CanvasRenderingContext2D::putImageData(ImageData* data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)

- ImageBuffer* buffer = canvas()->buffer();

- if (!buffer)

- return;

- if (dirtyWidth < 0) {

- dirtyX += dirtyWidth;

- dirtyWidth = -dirtyWidth;

- }

- if (dirtyHeight < 0) {

- dirtyY += dirtyHeight;

- dirtyHeight = -dirtyHeight;

- }

- FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);

- clipRect.intersect(IntRect(0, 0, data->width(), data->height()));

- IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));

- IntRect destRect = enclosingIntRect(clipRect);

- destRect.move(destOffset);

- destRect.intersect(IntRect(IntPoint(), buffer->size()));

- if (destRect.isEmpty())

- return;

- IntRect sourceRect(destRect);

- sourceRect.move(-destOffset);

- buffer->putByteArray(Unmultiplied, data->data(), IntSize(data->width(), data->height()), sourceRect, IntPoint(destOffset));

- didDraw(destRect);

-String CanvasRenderingContext2D::font() const

- if (!state().m_realizedFont)

- return defaultFont;

- StringBuilder serializedFont;

- const FontDescription& fontDescription = state().m_font.fontDescription();

- if (fontDescription.style() == FontStyleItalic)

- serializedFont.appendLiteral("italic ");

- if (fontDescription.weight() == FontWeightBold)

- serializedFont.appendLiteral("bold ");

- if (fontDescription.variant() == FontVariantSmallCaps)

- serializedFont.appendLiteral("small-caps ");

- serializedFont.appendNumber(fontDescription.computedPixelSize());

- serializedFont.appendLiteral("px");

- const FontFamily& firstFontFamily = fontDescription.family();

- for (const FontFamily* fontFamily = &firstFontFamily; fontFamily; fontFamily = fontFamily->next()) {

- if (fontFamily != &firstFontFamily)

- serializedFont.append(',');

- // FIXME: We should append family directly to serializedFont rather than building a temporary string.

- String family = fontFamily->family();

- if (family.startsWith("-webkit-"))

- family = family.substring(8);

- if (family.contains(' '))

- family = "\"" + family + "\"";

- serializedFont.append(' ');

- serializedFont.append(family);

- }

- return serializedFont.toString();

-void CanvasRenderingContext2D::setFont(const String& newFont)

- // The style resolution required for rendering text is not available in frame-less documents.

- if (!canvas()->document().frame())

- return;

- MutableStylePropertyMap::iterator i = m_fetchedFonts.find(newFont);

- RefPtr<MutableStylePropertySet> parsedStyle = i != m_fetchedFonts.end() ? i->value : nullptr;

- if (!parsedStyle) {

- parsedStyle = MutableStylePropertySet::create();

- BisonCSSParser::parseValue(parsedStyle.get(), CSSPropertyFont, newFont, HTMLStandardMode, 0);

- m_fetchedFonts.add(newFont, parsedStyle);

- }

- if (parsedStyle->isEmpty())

- return;

- String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);

- // According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,

- // the "inherit" and "initial" values must be ignored.

- if (fontValue == "inherit" || fontValue == "initial")

- return;

- // The parse succeeded.

- String newFontSafeCopy(newFont); // Create a string copy since newFont can be deleted inside realizeSaves.

- realizeSaves(0);

- modifiableState().m_unparsedFont = newFontSafeCopy;

- // Map the <canvas> font into the text style. If the font uses keywords like larger/smaller, these will work

- // relative to the canvas.

- RefPtr<RenderStyle> newStyle = RenderStyle::create();

- if (RenderStyle* computedStyle = canvas()->computedStyle()) {

- FontDescription elementFontDescription(computedStyle->fontDescription());

- // Reset the computed size to avoid inheriting the zoom factor from the <canvas> element.

- elementFontDescription.setComputedSize(elementFontDescription.specifiedSize());

- newStyle->setFontDescription(elementFontDescription);

- } else {

- FontFamily fontFamily;

- fontFamily.setFamily(defaultFontFamily);

- FontDescription defaultFontDescription;

- defaultFontDescription.setFamily(fontFamily);

- defaultFontDescription.setSpecifiedSize(defaultFontSize);

- defaultFontDescription.setComputedSize(defaultFontSize);

- newStyle->setFontDescription(defaultFontDescription);

- }

- newStyle->font().update(newStyle->font().fontSelector());

- // Now map the font property longhands into the style.

- CSSPropertyValue properties[] = {

- CSSPropertyValue(CSSPropertyFontFamily, *parsedStyle),

- CSSPropertyValue(CSSPropertyFontStyle, *parsedStyle),

- CSSPropertyValue(CSSPropertyFontVariant, *parsedStyle),

- CSSPropertyValue(CSSPropertyFontWeight, *parsedStyle),

- CSSPropertyValue(CSSPropertyFontSize, *parsedStyle),

- CSSPropertyValue(CSSPropertyLineHeight, *parsedStyle),

- };

- StyleResolver& styleResolver = canvas()->document().styleResolver();

- styleResolver.applyPropertiesToStyle(properties, WTF_ARRAY_LENGTH(properties), newStyle.get());

-#if !ENABLE(OILPAN)

- if (state().m_realizedFont)

- static_cast<CSSFontSelector*>(state().m_font.fontSelector())->unregisterForInvalidationCallbacks(&modifiableState());

-#endif

- modifiableState().m_font = newStyle->font();

- modifiableState().m_font.update(canvas()->document().styleEngine()->fontSelector());

- modifiableState().m_realizedFont = true;

- canvas()->document().styleEngine()->fontSelector()->registerForInvalidationCallbacks(&modifiableState());

-String CanvasRenderingContext2D::textAlign() const

- return textAlignName(state().m_textAlign);

-void CanvasRenderingContext2D::setTextAlign(const String& s)

- TextAlign align;

- if (!parseTextAlign(s, align))

- return;

- if (state().m_textAlign == align)

- return;

- realizeSaves(0);

- modifiableState().m_textAlign = align;

-String CanvasRenderingContext2D::textBaseline() const

- return textBaselineName(state().m_textBaseline);

-void CanvasRenderingContext2D::setTextBaseline(const String& s)

- TextBaseline baseline;

- if (!parseTextBaseline(s, baseline))

- return;

- if (state().m_textBaseline == baseline)

- return;

- realizeSaves(0);

- modifiableState().m_textBaseline = baseline;

-inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, RenderStyle** computedStyle) const

- RenderStyle* style = (computedStyle || direction == DirectionInherit) ? canvas()->computedStyle() : nullptr;

- if (computedStyle)

- *computedStyle = style;

- switch (direction) {

- case DirectionInherit:

- return style ? style->direction() : LTR;

- case DirectionRTL:

- return RTL;

- case DirectionLTR:

- return LTR;

- }

- ASSERT_NOT_REACHED();

- return LTR;

-String CanvasRenderingContext2D::direction() const

- if (state().m_direction == DirectionInherit)

- canvas()->document().updateRenderTreeIfNeeded();

- return toTextDirection(state().m_direction) == RTL ? rtl : ltr;

-void CanvasRenderingContext2D::setDirection(const String& directionString)

- Direction direction;

- if (directionString == inherit)

- direction = DirectionInherit;

- else if (directionString == rtl)

- direction = DirectionRTL;

- else if (directionString == ltr)

- direction = DirectionLTR;

- else

- return;

- if (state().m_direction == direction)

- return;

- realizeSaves(0);

- modifiableState().m_direction = direction;

-void CanvasRenderingContext2D::fillText(const String& text, float x, float y)

- drawTextInternal(text, x, y, true);

-void CanvasRenderingContext2D::fillText(const String& text, float x, float y, float maxWidth)

- drawTextInternal(text, x, y, true, maxWidth, true);

-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y)

- drawTextInternal(text, x, y, false);

-void CanvasRenderingContext2D::strokeText(const String& text, float x, float y, float maxWidth)

- drawTextInternal(text, x, y, false, maxWidth, true);

-static inline bool isSpaceCharacter(UChar c)

- // According to specification all space characters should be replaced with 0x0020 space character.

- // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#text-preparation-algorithm

- // The space characters according to specification are : U+0020, U+0009, U+000A, U+000C, and U+000D.

- // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#space-character

- // This function returns true for 0x000B also, so that this is backward compatible.

- // Otherwise, the test tests/canvas/philip/tests/2d.text.draw.space.collapse.space.html will fail

- return c == 0x0009 || c == 0x000A || c == 0x000B || c == 0x000C || c == 0x000D;

-static String normalizeSpaces(const String& text)

- unsigned textLength = text.length();

- Vector<UChar> charVector(textLength);

- for (unsigned i = 0; i < textLength; i++) {

- if (isSpaceCharacter(text[i]))

- charVector[i] = ' ';

- else

- charVector[i] = text[i];

- }

- return String(charVector);

-PassRefPtr<TextMetrics> CanvasRenderingContext2D::measureText(const String& text)

- RefPtr<TextMetrics> metrics = TextMetrics::create();

- // The style resolution required for rendering text is not available in frame-less documents.

- if (!canvas()->document().frame())

- return metrics.release();

- FontCachePurgePreventer fontCachePurgePreventer;

- canvas()->document().updateRenderTreeIfNeeded();

- const Font& font = accessFont();

- String normalizedText = normalizeSpaces(text);

- const TextRun textRun(normalizedText);

- FloatRect textBounds = font.selectionRectForText(textRun, FloatPoint(), font.fontDescription().computedSize(), 0, -1, true);

- // x direction

- metrics->setWidth(font.width(textRun));

- metrics->setActualBoundingBoxLeft(-textBounds.x());

- metrics->setActualBoundingBoxRight(textBounds.maxX());

- // y direction

- const FontMetrics& fontMetrics = font.fontMetrics();

- const float ascent = fontMetrics.floatAscent();

- const float descent = fontMetrics.floatDescent();

- const float baselineY = getFontBaseline(fontMetrics);

- metrics->setFontBoundingBoxAscent(ascent - baselineY);

- metrics->setFontBoundingBoxDescent(descent + baselineY);

- metrics->setActualBoundingBoxAscent(-textBounds.y() - baselineY);

- metrics->setActualBoundingBoxDescent(textBounds.maxY() + baselineY);

- // Note : top/bottom and ascend/descend are currently the same, so there's no difference

- // between the EM box's top and bottom and the font's ascend and descend

- metrics->setEmHeightAscent(0);

- metrics->setEmHeightDescent(0);

- metrics->setHangingBaseline(-0.8f * ascent + baselineY);

- metrics->setAlphabeticBaseline(baselineY);

- metrics->setIdeographicBaseline(descent + baselineY);

- return metrics.release();

-void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, float y, bool fill, float maxWidth, bool useMaxWidth)

- // The style resolution required for rendering text is not available in frame-less documents.

- if (!canvas()->document().frame())

- return;

- // accessFont needs the style to be up to date, but updating style can cause script to run,

- // which can free the GraphicsContext, so update style before grabbing the GraphicsContext.

- // TODO(esprehn): This isn't needed in sky.

- canvas()->document().updateRenderTreeIfNeeded();

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- if (!state().m_invertibleCTM)

- return;

- if (!std::isfinite(x) | !std::isfinite(y))

- return;

- if (useMaxWidth && (!std::isfinite(maxWidth) || maxWidth <= 0))

- return;

- // If gradient size is zero, then paint nothing.

- Gradient* gradient = c->strokeGradient();

- if (!fill && gradient && gradient->isZeroSize())

- return;

- gradient = c->fillGradient();

- if (fill && gradient && gradient->isZeroSize())

- return;

- FontCachePurgePreventer fontCachePurgePreventer;

- const Font& font = accessFont();

- const FontMetrics& fontMetrics = font.fontMetrics();

- String normalizedText = normalizeSpaces(text);

- // FIXME: Need to turn off font smoothing.

- RenderStyle* computedStyle;

- TextDirection direction = toTextDirection(state().m_direction, &computedStyle);

- bool isRTL = direction == RTL;

- bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;

- TextRun textRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, direction, override, true);

- // Draw the item text at the correct point.

- FloatPoint location(x, y + getFontBaseline(fontMetrics));

- float fontWidth = font.width(TextRun(normalizedText, 0, 0, TextRun::AllowTrailingExpansion, direction, override));

- useMaxWidth = (useMaxWidth && maxWidth < fontWidth);

- float width = useMaxWidth ? maxWidth : fontWidth;

- TextAlign align = state().m_textAlign;

- if (align == StartTextAlign)

- align = isRTL ? RightTextAlign : LeftTextAlign;

- else if (align == EndTextAlign)

- align = isRTL ? LeftTextAlign : RightTextAlign;

- switch (align) {

- case CenterTextAlign:

- location.setX(location.x() - width / 2);

- break;

- case RightTextAlign:

- location.setX(location.x() - width);

- break;

- default:

- break;

- }

- // The slop built in to this mask rect matches the heuristic used in FontCGWin.cpp for GDI text.

- TextRunPaintInfo textRunPaintInfo(textRun);

- textRunPaintInfo.bounds = FloatRect(location.x() - fontMetrics.height() / 2,

- location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),

- width + fontMetrics.height(),

- fontMetrics.lineSpacing());

- if (!fill)

- inflateStrokeRect(textRunPaintInfo.bounds);

- c->setTextDrawingMode(fill ? TextModeFill : TextModeStroke);

- GraphicsContextStateSaver stateSaver(*c);

- if (useMaxWidth) {

- c->translate(location.x(), location.y());

- // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.

- c->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);

- location = FloatPoint();

- }

- FloatRect clipBounds;

- if (!c->getTransformedClipBounds(&clipBounds)) {

- return;

- }

- FloatRect dirtyRect;

- if (computeDirtyRect(textRunPaintInfo.bounds, clipBounds, &dirtyRect)) {

- c->drawBidiText(font, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady);

- didDraw(dirtyRect);

- }

-void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const

- // Fast approximation of the stroke's bounding rect.

- // This yields a slightly oversized rect but is very fast

- // compared to Path::strokeBoundingRect().

- static const float root2 = sqrtf(2);

- float delta = state().m_lineWidth / 2;

- if (state().m_lineJoin == MiterJoin)

- delta *= state().m_miterLimit;

- else if (state().m_lineCap == SquareCap)

- delta *= root2;

- rect.inflate(delta);

-const Font& CanvasRenderingContext2D::accessFont()

- // This needs style to be up to date, but can't assert so because drawTextInternal

- // can invalidate style before this is called (e.g. drawingContext invalidates style).

- if (!state().m_realizedFont)

- setFont(state().m_unparsedFont);

- return state().m_font;

-int CanvasRenderingContext2D::getFontBaseline(const FontMetrics& fontMetrics) const

- switch (state().m_textBaseline) {

- case TopTextBaseline:

- return fontMetrics.ascent();

- case HangingTextBaseline:

- // According to http://wiki.apache.org/xmlgraphics-fop/LineLayout/AlignmentHandling

- // "FOP (Formatting Objects Processor) puts the hanging baseline at 80% of the ascender height"

- return (fontMetrics.ascent() * 4) / 5;

- case BottomTextBaseline:

- case IdeographicTextBaseline:

- return -fontMetrics.descent();

- case MiddleTextBaseline:

- return -fontMetrics.descent() + fontMetrics.height() / 2;

- case AlphabeticTextBaseline:

- default:

- // Do nothing.

- break;

- }

- return 0;

-void CanvasRenderingContext2D::setIsHidden(bool hidden)

- ImageBuffer* buffer = canvas()->buffer();

- if (buffer)

- buffer->setIsHidden(hidden);

-blink::WebLayer* CanvasRenderingContext2D::platformLayer() const

- return canvas()->buffer() ? canvas()->buffer()->platformLayer() : 0;

-bool CanvasRenderingContext2D::imageSmoothingEnabled() const

- return state().m_imageSmoothingEnabled;

-void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)

- if (enabled == state().m_imageSmoothingEnabled)

- return;

- GraphicsContext* c = drawingContext();

- realizeSaves(c);

- modifiableState().m_imageSmoothingEnabled = enabled;

- if (c)

- c->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);

-PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const

- RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();

- return attributes.release();

-void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)

- drawFocusIfNeededInternal(m_path, element);

-void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D* path2d, Element* element)

- drawFocusIfNeededInternal(path2d->path(), element);

-void CanvasRenderingContext2D::drawFocusIfNeededInternal(const Path& path, Element* element)

- if (!focusRingCallIsValid(path, element))

- return;

- // Note: we need to check document->focusedElement() rather than just calling

- // element->focused(), because element->focused() isn't updated until after

- // focus events fire.

- if (element->document().focusedElement() == element)

- drawFocusRing(path);

-bool CanvasRenderingContext2D::focusRingCallIsValid(const Path& path, Element* element)

- ASSERT(element);

- if (!state().m_invertibleCTM)

- return false;

- if (path.isEmpty())

- return false;

- if (!element->isDescendantOf(canvas()))

- return false;

- return true;

-void CanvasRenderingContext2D::drawFocusRing(const Path& path)

- GraphicsContext* c = drawingContext();

- if (!c)

- return;

- // These should match the style defined in html.css.

- Color focusRingColor = RenderTheme::theme().focusRingColor();

- const int focusRingWidth = 5;

- const int focusRingOutline = 0;

- // We need to add focusRingWidth to dirtyRect.

- StrokeData strokeData;

- strokeData.setThickness(focusRingWidth);

- FloatRect dirtyRect;

- if (!computeDirtyRect(path.strokeBoundingRect(strokeData), &dirtyRect))

- return;

- c->save();

- c->setAlphaAsFloat(1.0);

- c->clearShadow();

- c->setCompositeOperation(CompositeSourceOver, blink::WebBlendModeNormal);

- c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);

- c->restore();

- validateStateStack();

- didDraw(dirtyRect);

-void CanvasRenderingContext2D::addHitRegion(ExceptionState& exceptionState)

- HitRegionOptions passOptions;

- RefPtr<Path2D> path2d;

- Path hitRegionPath = path2d ? path2d->path() : m_path;

- FloatRect clipBounds;

- GraphicsContext* context = drawingContext();

- if (hitRegionPath.isEmpty() || !context || !state().m_invertibleCTM

- || !context->getTransformedClipBounds(&clipBounds)) {

- exceptionState.ThrowDOMException(NotSupportedError, "The specified path has no pixels.");

- return;

- }

- hitRegionPath.transform(state().m_transform);

- if (hasClip()) {

- // FIXME: The hit regions should take clipping region into account.

- // However, we have no way to get the region from canvas state stack by now.

- // See http://crbug.com/387057

- exceptionState.ThrowDOMException(NotSupportedError, "The specified path has no pixels.");

- return;

- }

- passOptions.path = hitRegionPath;

- // FIXME(Dictionary): Way to specify fillRule

- passOptions.fillRule = RULE_NONZERO;

- addHitRegionInternal(passOptions, exceptionState);

-void CanvasRenderingContext2D::addHitRegionInternal(const HitRegionOptions& options, ExceptionState& exceptionState)

- if (!m_hitRegionManager)

- m_hitRegionManager = HitRegionManager::create();

- // Remove previous region (with id or control)

- m_hitRegionManager->removeHitRegionById(options.id);

- m_hitRegionManager->removeHitRegionByControl(options.control.get());

- RefPtr<HitRegion> hitRegion = HitRegion::create(options);

- hitRegion->updateAccessibility(canvas());

- m_hitRegionManager->addHitRegion(hitRegion.release());

-void CanvasRenderingContext2D::removeHitRegion(const String& id)

- if (m_hitRegionManager)

- m_hitRegionManager->removeHitRegionById(id);

-void CanvasRenderingContext2D::clearHitRegions()

- if (m_hitRegionManager)

- m_hitRegionManager->removeAllHitRegions();

-HitRegion* CanvasRenderingContext2D::hitRegionAtPoint(const LayoutPoint& point)

- if (m_hitRegionManager)

- return m_hitRegionManager->getHitRegionAtPoint(point);

- return 0;

-unsigned CanvasRenderingContext2D::hitRegionsCount() const

- if (m_hitRegionManager)

- return m_hitRegionManager->getHitRegionsCount();

- return 0;

-} // namespace blink

« no previous file with comments | « sky/engine/core/html/canvas/CanvasRenderingContext2D.h ('k') | sky/engine/core/html/canvas/CanvasRenderingContext2D.idl » ('j') | no next file with comments »