Changeset 208206 in webkit


Ignore:
Timestamp:
Oct 31, 2016, 6:36:00 PM (9 years ago)
Author:
mmaxfield@apple.com
Message:

Migrate CanvasRenderingContext's internal canvas pointer to a reference
​https://bugs.webkit.org/show_bug.cgi?id=164259

Reviewed by Dean Jackson.

It is never nullptr.

No new tests because there is no behavior change.

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::getContext):

  • html/canvas/CanvasRenderingContext.cpp:

(WebCore::CanvasRenderingContext::CanvasRenderingContext):
(WebCore::CanvasRenderingContext::wouldTaintOrigin):
(WebCore::CanvasRenderingContext::checkOrigin):

  • html/canvas/CanvasRenderingContext.h:

(WebCore::CanvasRenderingContext::ref):
(WebCore::CanvasRenderingContext::deref):
(WebCore::CanvasRenderingContext::canvas):
(WebCore::CanvasRenderingContext::checkOrigin):

  • html/canvas/CanvasRenderingContext2D.cpp:

(WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
(WebCore::CanvasRenderingContext2D::unwindStateStack):
(WebCore::CanvasRenderingContext2D::isAccelerated):
(WebCore::CanvasRenderingContext2D::realizeSaves):
(WebCore::CanvasRenderingContext2D::setStrokeStyle):
(WebCore::CanvasRenderingContext2D::setFillStyle):
(WebCore::CanvasRenderingContext2D::setShadowColor):
(WebCore::CanvasRenderingContext2D::resetTransform):
(WebCore::CanvasRenderingContext2D::setStrokeColor):
(WebCore::CanvasRenderingContext2D::setFillColor):
(WebCore::CanvasRenderingContext2D::setShadow):
(WebCore::CanvasRenderingContext2D::clearCanvas):
(WebCore::CanvasRenderingContext2D::transformAreaToDevice):
(WebCore::CanvasRenderingContext2D::rectContainsCanvas):
(WebCore::CanvasRenderingContext2D::calculateCompositingBufferRect):
(WebCore::CanvasRenderingContext2D::compositeBuffer):
(WebCore::CanvasRenderingContext2D::createPattern):
(WebCore::CanvasRenderingContext2D::didDrawEntireCanvas):
(WebCore::CanvasRenderingContext2D::didDraw):
(WebCore::CanvasRenderingContext2D::paintRenderingResultsToCanvas):
(WebCore::CanvasRenderingContext2D::drawingContext):
(WebCore::CanvasRenderingContext2D::getImageData):
(WebCore::CanvasRenderingContext2D::drawFocusIfNeededInternal):
(WebCore::CanvasRenderingContext2D::putImageData):
(WebCore::CanvasRenderingContext2D::setFont):
(WebCore::CanvasRenderingContext2D::toTextDirection):
(WebCore::CanvasRenderingContext2D::direction):
(WebCore::CanvasRenderingContext2D::platformLayer):

  • html/canvas/WebGL2RenderingContext.cpp:

(WebCore::WebGL2RenderingContext::WebGL2RenderingContext):

  • html/canvas/WebGL2RenderingContext.h:
  • html/canvas/WebGLRenderingContext.cpp:

(WebCore::WebGLRenderingContext::WebGLRenderingContext):

  • html/canvas/WebGLRenderingContext.h:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::create):
(WebCore::WebGLRenderingContextBase::WebGLRenderingContextBase):
(WebCore::WebGLRenderingContextBase::setupFlags):
(WebCore::WebGLRenderingContextBase::markContextChanged):
(WebCore::WebGLRenderingContextBase::paintRenderingResultsToCanvas):
(WebCore::WebGLRenderingContextBase::reshape):
(WebCore::WebGLRenderingContextBase::isContextLostOrPending):
(WebCore::WebGLRenderingContextBase::readPixels):
(WebCore::WebGLRenderingContextBase::loseContextImpl):
(WebCore::WebGLRenderingContextBase::printWarningToConsole):
(WebCore::WebGLRenderingContextBase::dispatchContextLostEvent):
(WebCore::WebGLRenderingContextBase::maybeRestoreContext):
(WebCore::WebGLRenderingContextBase::clampedCanvasSize):

  • html/canvas/WebGLRenderingContextBase.h:
Location:
trunk/Source/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r208203 r208206  
     12016-10-31  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Migrate CanvasRenderingContext's internal canvas pointer to a reference
     4        https://bugs.webkit.org/show_bug.cgi?id=164259
     5
     6        Reviewed by Dean Jackson.
     7
     8        It is never nullptr.
     9
     10        No new tests because there is no behavior change.
     11
     12        * html/HTMLCanvasElement.cpp:
     13        (WebCore::HTMLCanvasElement::getContext):
     14        * html/canvas/CanvasRenderingContext.cpp:
     15        (WebCore::CanvasRenderingContext::CanvasRenderingContext):
     16        (WebCore::CanvasRenderingContext::wouldTaintOrigin):
     17        (WebCore::CanvasRenderingContext::checkOrigin):
     18        * html/canvas/CanvasRenderingContext.h:
     19        (WebCore::CanvasRenderingContext::ref):
     20        (WebCore::CanvasRenderingContext::deref):
     21        (WebCore::CanvasRenderingContext::canvas):
     22        (WebCore::CanvasRenderingContext::checkOrigin):
     23        * html/canvas/CanvasRenderingContext2D.cpp:
     24        (WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
     25        (WebCore::CanvasRenderingContext2D::unwindStateStack):
     26        (WebCore::CanvasRenderingContext2D::isAccelerated):
     27        (WebCore::CanvasRenderingContext2D::realizeSaves):
     28        (WebCore::CanvasRenderingContext2D::setStrokeStyle):
     29        (WebCore::CanvasRenderingContext2D::setFillStyle):
     30        (WebCore::CanvasRenderingContext2D::setShadowColor):
     31        (WebCore::CanvasRenderingContext2D::resetTransform):
     32        (WebCore::CanvasRenderingContext2D::setStrokeColor):
     33        (WebCore::CanvasRenderingContext2D::setFillColor):
     34        (WebCore::CanvasRenderingContext2D::setShadow):
     35        (WebCore::CanvasRenderingContext2D::clearCanvas):
     36        (WebCore::CanvasRenderingContext2D::transformAreaToDevice):
     37        (WebCore::CanvasRenderingContext2D::rectContainsCanvas):
     38        (WebCore::CanvasRenderingContext2D::calculateCompositingBufferRect):
     39        (WebCore::CanvasRenderingContext2D::compositeBuffer):
     40        (WebCore::CanvasRenderingContext2D::createPattern):
     41        (WebCore::CanvasRenderingContext2D::didDrawEntireCanvas):
     42        (WebCore::CanvasRenderingContext2D::didDraw):
     43        (WebCore::CanvasRenderingContext2D::paintRenderingResultsToCanvas):
     44        (WebCore::CanvasRenderingContext2D::drawingContext):
     45        (WebCore::CanvasRenderingContext2D::getImageData):
     46        (WebCore::CanvasRenderingContext2D::drawFocusIfNeededInternal):
     47        (WebCore::CanvasRenderingContext2D::putImageData):
     48        (WebCore::CanvasRenderingContext2D::setFont):
     49        (WebCore::CanvasRenderingContext2D::toTextDirection):
     50        (WebCore::CanvasRenderingContext2D::direction):
     51        (WebCore::CanvasRenderingContext2D::platformLayer):
     52        * html/canvas/WebGL2RenderingContext.cpp:
     53        (WebCore::WebGL2RenderingContext::WebGL2RenderingContext):
     54        * html/canvas/WebGL2RenderingContext.h:
     55        * html/canvas/WebGLRenderingContext.cpp:
     56        (WebCore::WebGLRenderingContext::WebGLRenderingContext):
     57        * html/canvas/WebGLRenderingContext.h:
     58        * html/canvas/WebGLRenderingContextBase.cpp:
     59        (WebCore::WebGLRenderingContextBase::create):
     60        (WebCore::WebGLRenderingContextBase::WebGLRenderingContextBase):
     61        (WebCore::WebGLRenderingContextBase::setupFlags):
     62        (WebCore::WebGLRenderingContextBase::markContextChanged):
     63        (WebCore::WebGLRenderingContextBase::paintRenderingResultsToCanvas):
     64        (WebCore::WebGLRenderingContextBase::reshape):
     65        (WebCore::WebGLRenderingContextBase::isContextLostOrPending):
     66        (WebCore::WebGLRenderingContextBase::readPixels):
     67        (WebCore::WebGLRenderingContextBase::loseContextImpl):
     68        (WebCore::WebGLRenderingContextBase::printWarningToConsole):
     69        (WebCore::WebGLRenderingContextBase::dispatchContextLostEvent):
     70        (WebCore::WebGLRenderingContextBase::maybeRestoreContext):
     71        (WebCore::WebGLRenderingContextBase::clampedCanvasSize):
     72        * html/canvas/WebGLRenderingContextBase.h:
     73
    1742016-10-31  Brady Eidson  <beidson@apple.com>
    275

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r208096 r208206  
    248248                return nullptr;
    249249            if (!m_context) {
    250                 m_context = WebGLRenderingContextBase::create(this, static_cast<WebGLContextAttributes*>(attrs), type);
     250                m_context = WebGLRenderingContextBase::create(*this, static_cast<WebGLContextAttributes*>(attrs), type);
    251251                if (m_context) {
    252252                    // Need to make sure a RenderLayer and compositing layer get created for the Canvas

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext.cpp

    r207720 r208206  
    3737namespace WebCore {
    3838
    39 CanvasRenderingContext::CanvasRenderingContext(HTMLCanvasElement* canvas)
     39CanvasRenderingContext::CanvasRenderingContext(HTMLCanvasElement& canvas)
    4040    : m_canvas(canvas)
    4141{
    … …  
    4444bool CanvasRenderingContext::wouldTaintOrigin(const CanvasPattern* pattern)
    4545{
    46     if (canvas()->originClean() && pattern && !pattern->originClean())
     46    if (canvas().originClean() && pattern && !pattern->originClean())
    4747        return true;
    4848    return false;
    … …  
    5151bool CanvasRenderingContext::wouldTaintOrigin(const HTMLCanvasElement* sourceCanvas)
    5252{
    53     if (canvas()->originClean() && sourceCanvas && !sourceCanvas->originClean())
     53    if (canvas().originClean() && sourceCanvas && !sourceCanvas->originClean())
    5454        return true;
    5555    return false;
    … …  
    5858bool CanvasRenderingContext::wouldTaintOrigin(const HTMLImageElement* element)
    5959{
    60     if (!element || !canvas()->originClean())
     60    if (!element || !canvas().originClean())
    6161        return false;
    6262
    … …  
    7575        return true;
    7676
    77     ASSERT(canvas()->securityOrigin());
     77    ASSERT(canvas().securityOrigin());
    7878    ASSERT(cachedImage->origin());
    79     ASSERT(canvas()->securityOrigin()->toString() == cachedImage->origin()->toString());
     79    ASSERT(canvas().securityOrigin()->toString() == cachedImage->origin()->toString());
    8080    return false;
    8181}
    … …  
    8888    // make currentSrc be the final URL because then the
    8989    // HTMLMediaElement.currentSrc DOM API would leak redirect destinations!
    90     if (!video || !canvas()->originClean())
     90    if (!video || !canvas().originClean())
    9191        return false;
    9292
    … …  
    106106bool CanvasRenderingContext::wouldTaintOrigin(const URL& url)
    107107{
    108     if (!canvas()->originClean())
     108    if (!canvas().originClean())
    109109        return false;
    110110
    … …  
    112112        return false;
    113113
    114     return !canvas()->securityOrigin()->canRequest(url);
     114    return !canvas().securityOrigin()->canRequest(url);
    115115}
    116116
    … …  
    118118{
    119119    if (wouldTaintOrigin(url))
    120         canvas()->setOriginTainted();
     120        canvas().setOriginTainted();
    121121}
    122122

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext.h

    r208179 r208206  
    4747    virtual ~CanvasRenderingContext() { }
    4848
    49     void ref() { m_canvas->ref(); }
    50     void deref() { m_canvas->deref(); }
    51     HTMLCanvasElement* canvas() const { return m_canvas; }
     49    void ref() { m_canvas.ref(); }
     50    void deref() { m_canvas.deref(); }
     51    HTMLCanvasElement& canvas() const { return m_canvas; }
    5252
    5353    virtual bool is2d() const { return false; }
    … …  
    6161
    6262protected:
    63     CanvasRenderingContext(HTMLCanvasElement*);
     63    CanvasRenderingContext(HTMLCanvasElement&);
    6464    bool wouldTaintOrigin(const CanvasPattern*);
    6565    bool wouldTaintOrigin(const HTMLCanvasElement*);
    … …  
    7171    {
    7272        if (wouldTaintOrigin(arg))
    73             canvas()->setOriginTainted();
     73            canvas().setOriginTainted();
    7474    }
    7575    void checkOrigin(const URL&);
    7676
    7777private:
    78     HTMLCanvasElement* m_canvas;
     78    HTMLCanvasElement& m_canvas;
    7979};
    8080

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r208000 r208206  
    134134
    135135CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
    136     : CanvasRenderingContext(&canvas)
     136    : CanvasRenderingContext(canvas)
    137137    , m_stateStack(1)
    138138    , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
    … …  
    152152    // GraphicsContext dtor.
    153153    if (size_t stackSize = m_stateStack.size()) {
    154         if (GraphicsContext* context = canvas()->existingDrawingContext()) {
     154        if (GraphicsContext* context = canvas().existingDrawingContext()) {
    155155            while (--stackSize)
    156156                context->restore();
    … …  
    172172{
    173173#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
    174     if (!canvas()->hasCreatedImageBuffer())
     174    if (!canvas().hasCreatedImageBuffer())
    175175        return false;
    176176    GraphicsContext* context = drawingContext();
    … …  
    359359    if (m_unrealizedSaveCount) {
    360360        static NeverDestroyed<String> consoleMessage(ASCIILiteral("CanvasRenderingContext2D.save() has been called without a matching restore() too many times. Ignoring save()."));
    361         canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage);
     361        canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage);
    362362    }
    363363}
    … …  
    407407        if (style.hasOverrideAlpha()) {
    408408            // FIXME: Should not use RGBA32 here.
    409             style = CanvasStyle(colorWithOverrideAlpha(currentColor(canvas()).rgb(), style.overrideAlpha()));
     409            style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
    410410        } else
    411             style = CanvasStyle(currentColor(canvas()));
     411            style = CanvasStyle(currentColor(&canvas()));
    412412    } else
    413413        checkOrigin(style.canvasPattern());
    … …  
    434434        if (style.hasOverrideAlpha()) {
    435435            // FIXME: Should not use RGBA32 here.
    436             style = CanvasStyle(colorWithOverrideAlpha(currentColor(canvas()).rgb(), style.overrideAlpha()));
     436            style = CanvasStyle(colorWithOverrideAlpha(currentColor(&canvas()).rgb(), style.overrideAlpha()));
    437437        } else
    438             style = CanvasStyle(currentColor(canvas()));
     438            style = CanvasStyle(currentColor(&canvas()));
    439439    } else
    440440        checkOrigin(style.canvasPattern());
    … …  
    583583void CanvasRenderingContext2D::setShadowColor(const String& colorString)
    584584{
    585     Color color = parseColorOrCurrentColor(colorString, canvas());
     585    Color color = parseColorOrCurrentColor(colorString, &canvas());
    586586    if (!color.isValid())
    587587        return;
    … …  
    825825    realizeSaves();
    826826
    827     c->setCTM(canvas()->baseTransform());
     827    c->setCTM(canvas().baseTransform());
    828828    modifiableState().transform = AffineTransform();
    829829
    … …  
    845845
    846846    realizeSaves();
    847     setStrokeStyle(CanvasStyle::createFromString(color, &canvas()->document()));
     847    setStrokeStyle(CanvasStyle::createFromString(color, &canvas().document()));
    848848    modifiableState().unparsedStrokeColor = color;
    849849}
    … …  
    881881
    882882    realizeSaves();
    883     setFillStyle(CanvasStyle::createFromString(color, &canvas()->document()));
     883    setFillStyle(CanvasStyle::createFromString(color, &canvas().document()));
    884884    modifiableState().unparsedFillColor = color;
    885885}
    … …  
    12531253void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& colorString, Optional<float> alpha)
    12541254{
    1255     Color color = parseColorOrCurrentColor(colorString, canvas());
     1255    Color color = parseColorOrCurrentColor(colorString, &canvas());
    12561256    if (!colorString.isNull() && !color.isValid())
    12571257        return;
    … …  
    16041604void CanvasRenderingContext2D::clearCanvas()
    16051605{
    1606     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
     1606    FloatRect canvasRect(0, 0, canvas().width(), canvas().height());
    16071607    GraphicsContext* c = drawingContext();
    16081608    if (!c)
    … …  
    16101610
    16111611    c->save();
    1612     c->setCTM(canvas()->baseTransform());
     1612    c->setCTM(canvas().baseTransform());
    16131613    c->clearRect(canvasRect);
    16141614    c->restore();
    … …  
    16191619    Path transformed(path);
    16201620    transformed.transform(state().transform);
    1621     transformed.transform(canvas()->baseTransform());
     1621    transformed.transform(canvas().baseTransform());
    16221622    return transformed;
    16231623}
    … …  
    16331633{
    16341634    FloatQuad quad(rect);
    1635     FloatQuad canvasQuad(FloatRect(0, 0, canvas()->width(), canvas()->height()));
     1635    FloatQuad canvasQuad(FloatRect(0, 0, canvas().width(), canvas().height()));
    16361636    return state().transform.mapQuad(quad).containsQuad(canvasQuad);
    16371637}
    … …  
    16391639template<class T> IntRect CanvasRenderingContext2D::calculateCompositingBufferRect(const T& area, IntSize* croppedOffset)
    16401640{
    1641     IntRect canvasRect(0, 0, canvas()->width(), canvas()->height());
    1642     canvasRect = canvas()->baseTransform().mapRect(canvasRect);
     1641    IntRect canvasRect(0, 0, canvas().width(), canvas().height());
     1642    canvasRect = canvas().baseTransform().mapRect(canvasRect);
    16431643    Path path = transformAreaToDevice(area);
    16441644    IntRect bufferRect = enclosingIntRect(path.fastBoundingRect());
    … …  
    16571657void CanvasRenderingContext2D::compositeBuffer(ImageBuffer& buffer, const IntRect& bufferRect, CompositeOperator op)
    16581658{
    1659     IntRect canvasRect(0, 0, canvas()->width(), canvas()->height());
    1660     canvasRect = canvas()->baseTransform().mapRect(canvasRect);
     1659    IntRect canvasRect(0, 0, canvas().width(), canvas().height());
     1660    canvasRect = canvas().baseTransform().mapRect(canvasRect);
    16611661
    16621662    GraphicsContext* c = drawingContext();
    … …  
    17651765        return Exception { INVALID_STATE_ERR };
    17661766
    1767     bool originClean = cachedImage->isOriginClean(canvas()->securityOrigin());
     1767    bool originClean = cachedImage->isOriginClean(canvas().securityOrigin());
    17681768
    17691769    // FIXME: SVG images with animations can switch between clean and dirty (leaking cross-origin
    … …  
    18031803
    18041804    checkOrigin(&videoElement);
    1805     bool originClean = canvas()->originClean();
     1805    bool originClean = canvas().originClean();
    18061806
    18071807#if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
    … …  
    18201820void CanvasRenderingContext2D::didDrawEntireCanvas()
    18211821{
    1822     didDraw(FloatRect(FloatPoint::zero(), canvas()->size()), CanvasDidDrawApplyClip);
     1822    didDraw(FloatRect(FloatPoint::zero(), canvas().size()), CanvasDidDrawApplyClip);
    18231823}
    18241824
    … …  
    18341834    // If we are drawing to hardware and we have a composited layer, just call contentChanged().
    18351835    if (isAccelerated()) {
    1836         RenderBox* renderBox = canvas()->renderBox();
     1836        RenderBox* renderBox = canvas().renderBox();
    18371837        if (renderBox && renderBox->hasAcceleratedCompositing()) {
    18381838            renderBox->contentChanged(CanvasPixelsChanged);
    1839             canvas()->clearCopiedImage();
    1840             canvas()->notifyObserversCanvasChanged(r);
     1839            canvas().clearCopiedImage();
     1840            canvas().notifyObserversCanvasChanged(r);
    18411841            return;
    18421842        }
    … …  
    18641864    }
    18651865
    1866     canvas()->didDraw(dirtyRect);
     1866    canvas().didDraw(dirtyRect);
    18671867}
    18681868
    … …  
    19031903            return;
    19041904       
    1905         FloatRect clip(FloatPoint::zero(), canvas()->size());
    1906         DisplayList::Replayer replayer(*canvas()->drawingContext(), m_recordingContext->displayList);
     1905        FloatRect clip(FloatPoint::zero(), canvas().size());
     1906        DisplayList::Replayer replayer(*canvas().drawingContext(), m_recordingContext->displayList);
    19071907
    19081908        if (UNLIKELY(m_tracksDisplayListReplay)) {
    … …  
    19201920    if (UNLIKELY(m_usesDisplayListDrawing)) {
    19211921        if (!m_recordingContext)
    1922             m_recordingContext = std::make_unique<DisplayListDrawingContext>(FloatRect(FloatPoint::zero(), canvas()->size()));
     1922            m_recordingContext = std::make_unique<DisplayListDrawingContext>(FloatRect(FloatPoint::zero(), canvas().size()));
    19231923
    19241924        return &m_recordingContext->context;
    19251925    }
    19261926
    1927     return canvas()->drawingContext();
     1927    return canvas().drawingContext();
    19281928}
    19291929
    … …  
    19761976ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh) const
    19771977{
    1978     if (!canvas()->originClean()) {
     1978    if (!canvas().originClean()) {
    19791979        static NeverDestroyed<String> consoleMessage(ASCIILiteral("Unable to get image data from canvas because the canvas has been tainted by cross-origin data."));
    1980         canvas()->document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
     1980        canvas().document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
    19811981        return Exception { SECURITY_ERR };
    19821982    }
    … …  
    20032003
    20042004    IntRect imageDataRect = enclosingIntRect(logicalRect);
    2005     ImageBuffer* buffer = canvas()->buffer();
     2005    ImageBuffer* buffer = canvas().buffer();
    20062006    if (!buffer)
    20072007        return createEmptyImageData(imageDataRect.size());
    … …  
    20152015        consoleMessage.appendNumber(imageDataRect.height());
    20162016
    2017         canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage.toString());
     2017        canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage.toString());
    20182018        return Exception { INVALID_STATE_ERR };
    20192019    }
    … …  
    20562056    GraphicsContext* context = drawingContext();
    20572057
    2058     if (!element.focused() || !state().hasInvertibleTransform || path.isEmpty() || !element.isDescendantOf(canvas()) || !context)
     2058    if (!element.focused() || !state().hasInvertibleTransform || path.isEmpty() || !element.isDescendantOf(&canvas()) || !context)
    20592059        return;
    20602060
    … …  
    20642064void CanvasRenderingContext2D::putImageData(ImageData& data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
    20652065{
    2066     ImageBuffer* buffer = canvas()->buffer();
     2066    ImageBuffer* buffer = canvas().buffer();
    20672067    if (!buffer)
    20682068        return;
    … …  
    21532153    auto newStyle = RenderStyle::createPtr();
    21542154
    2155     Document& document = canvas()->document();
     2155    Document& document = canvas().document();
    21562156    document.updateStyleIfNeeded();
    21572157
    2158     if (auto* computedStyle = canvas()->computedStyle())
     2158    if (auto* computedStyle = canvas().computedStyle())
    21592159        newStyle->setFontDescription(computedStyle->fontDescription());
    21602160    else {
    … …  
    21702170
    21712171    // Now map the font property longhands into the style.
    2172     StyleResolver& styleResolver = canvas()->styleResolver();
     2172    StyleResolver& styleResolver = canvas().styleResolver();
    21732173    styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), WTFMove(newStyle));
    21742174    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());
    … …  
    22212221inline TextDirection CanvasRenderingContext2D::toTextDirection(Direction direction, const RenderStyle** computedStyle) const
    22222222{
    2223     auto* style = (computedStyle || direction == Direction::Inherit) ? canvas()->computedStyle() : nullptr;
     2223    auto* style = (computedStyle || direction == Direction::Inherit) ? canvas().computedStyle() : nullptr;
    22242224    if (computedStyle)
    22252225        *computedStyle = style;
    … …  
    22392239{
    22402240    if (state().direction == Direction::Inherit)
    2241         canvas()->document().updateStyleIfNeeded();
     2241        canvas().document().updateStyleIfNeeded();
    22422242    return toTextDirection(state().direction) == RTL ? ASCIILiteral("rtl") : ASCIILiteral("ltr");
    22432243}
    … …  
    25092509auto CanvasRenderingContext2D::fontProxy() -> const FontProxy&
    25102510{
    2511     canvas()->document().updateStyleIfNeeded();
     2511    canvas().document().updateStyleIfNeeded();
    25122512
    25132513    if (!state().font.realized())
    … …  
    25192519PlatformLayer* CanvasRenderingContext2D::platformLayer() const
    25202520{
    2521     return canvas()->buffer() ? canvas()->buffer()->platformLayer() : 0;
     2521    return canvas().buffer() ? canvas().buffer()->platformLayer() : 0;
    25222522}
    25232523#endif

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp

    r207724 r208206  
    6060namespace WebCore {
    6161
    62 WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
     62WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement& passedCanvas, GraphicsContext3D::Attributes attributes)
    6363    : WebGLRenderingContextBase(passedCanvas, attributes)
    6464{
    6565}
    6666
    67 WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, RefPtr<GraphicsContext3D>&& context, GraphicsContext3D::Attributes attributes)
     67WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement& passedCanvas, RefPtr<GraphicsContext3D>&& context, GraphicsContext3D::Attributes attributes)
    6868    : WebGLRenderingContextBase(passedCanvas, WTFMove(context), attributes)
    6969{

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.h

    r208032 r208206  
    4141class WebGL2RenderingContext final : public WebGLRenderingContextBase {
    4242public:
    43     WebGL2RenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);
    44     WebGL2RenderingContext(HTMLCanvasElement*, RefPtr<GraphicsContext3D>&&, GraphicsContext3D::Attributes);
     43    WebGL2RenderingContext(HTMLCanvasElement&, GraphicsContext3D::Attributes);
     44    WebGL2RenderingContext(HTMLCanvasElement&, RefPtr<GraphicsContext3D>&&, GraphicsContext3D::Attributes);
    4545
    4646    /* Buffer objects */

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContext.cpp

    r207724 r208206  
    6565namespace WebCore {
    6666
    67 WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
     67WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement& passedCanvas, GraphicsContext3D::Attributes attributes)
    6868    : WebGLRenderingContextBase(passedCanvas, attributes)
    6969{
    7070}
    7171
    72 WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,
     72WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement& passedCanvas, PassRefPtr<GraphicsContext3D> context,
    7373    GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, context, attributes)
    7474{

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContext.h

    r207724 r208206  
    3232class WebGLRenderingContext final : public WebGLRenderingContextBase {
    3333public:
    34     WebGLRenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);
    35     WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
     34    WebGLRenderingContext(HTMLCanvasElement&, GraphicsContext3D::Attributes);
     35    WebGLRenderingContext(HTMLCanvasElement&, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
    3636
    3737private:

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r208032 r208206  
    349349};
    350350
    351 std::unique_ptr<WebGLRenderingContextBase> WebGLRenderingContextBase::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs, const String& type)
     351std::unique_ptr<WebGLRenderingContextBase> WebGLRenderingContextBase::create(HTMLCanvasElement& canvas, WebGLContextAttributes* attrs, const String& type)
    352352{
    353353#if ENABLE(WEBGL2)
    … …  
    358358#endif
    359359
    360     Document& document = canvas->document();
     360    Document& document = canvas.document();
    361361    Frame* frame = document.frame();
    362362    if (!frame)
    … …  
    366366    // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
    367367    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {
    368         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));
     368        canvas.dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));
    369369        return nullptr;
    370370    }
    … …  
    427427
    428428    if (!context || !context->makeContextCurrent()) {
    429         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
     429        canvas.dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
    430430        return nullptr;
    431431    }
    … …  
    447447}
    448448
    449 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)
     449WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement& passedCanvas, GraphicsContext3D::Attributes attributes)
    450450    : CanvasRenderingContext(passedCanvas)
    451     , ActiveDOMObject(&passedCanvas->document())
     451    , ActiveDOMObject(&passedCanvas.document())
    452452    , m_context(nullptr)
    453453    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)
    … …  
    465465}
    466466
    467 WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, RefPtr<GraphicsContext3D>&& context, GraphicsContext3D::Attributes attributes)
     467WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement& passedCanvas, RefPtr<GraphicsContext3D>&& context, GraphicsContext3D::Attributes attributes)
    468468    : CanvasRenderingContext(passedCanvas)
    469     , ActiveDOMObject(&passedCanvas->document())
     469    , ActiveDOMObject(&passedCanvas.document())
    470470    , m_context(WTFMove(context))
    471471    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)
    … …  
    572572    ASSERT(m_context);
    573573
    574     if (Page* page = canvas()->document().page())
     574    if (Page* page = canvas().document().page())
    575575        m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();
    576576
    … …  
    641641
    642642    m_layerCleared = false;
    643     RenderBox* renderBox = canvas()->renderBox();
     643    RenderBox* renderBox = canvas().renderBox();
    644644    if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {
    645645        m_markedCanvasDirty = true;
    646         canvas()->clearCopiedImage();
     646        canvas().clearCopiedImage();
    647647        renderBox->contentChanged(CanvasChanged);
    648648    } else {
    649649        if (!m_markedCanvasDirty) {
    650650            m_markedCanvasDirty = true;
    651             canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
     651            canvas().didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
    652652        }
    653653    }
    … …  
    731731        return;
    732732
    733     if (canvas()->document().printing())
    734         canvas()->clearPresentationCopy();
     733    if (canvas().document().printing())
     734        canvas().clearPresentationCopy();
    735735
    736736    // Until the canvas is written to by the application, the clear that
    737737    // happened after it was composited should be ignored by the compositor.
    738738    if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {
    739         m_context->paintCompositedResultsToCanvas(canvas()->buffer());
    740 
    741         canvas()->makePresentationCopy();
     739        m_context->paintCompositedResultsToCanvas(canvas().buffer());
     740
     741        canvas().makePresentationCopy();
    742742    } else
    743         canvas()->clearPresentationCopy();
     743        canvas().clearPresentationCopy();
    744744    clearIfComposited();
    745745
    … …  
    747747        return;
    748748
    749     canvas()->clearCopiedImage();
     749    canvas().clearCopiedImage();
    750750    m_markedCanvasDirty = false;
    751751
    752     m_context->paintRenderingResultsToCanvas(canvas()->buffer());
     752    m_context->paintRenderingResultsToCanvas(canvas().buffer());
    753753}
    754754
    … …  
    783783
    784784    if (m_needsUpdate) {
    785         RenderBox* renderBox = canvas()->renderBox();
     785        RenderBox* renderBox = canvas().renderBox();
    786786        if (renderBox && renderBox->hasAcceleratedCompositing())
    787787            renderBox->contentChanged(CanvasChanged);
    … …  
    26812681    if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {
    26822682        LOG(WebGL, "Context is being used. Attempt to resolve the policy.");
    2683         Document& document = canvas()->document().topDocument();
     2683        Document& document = canvas().document().topDocument();
    26842684        Page* page = document.page();
    26852685        if (page && !document.url().isLocalFile())
    … …  
    28262826    // Due to WebGL's same-origin restrictions, it is not possible to
    28272827    // taint the origin using the WebGL API.
    2828     ASSERT(canvas()->originClean());
     2828    ASSERT(canvas().originClean());
    28292829    // Validate input parameters.
    28302830    switch (format) {
    … …  
    38113811        // Inform the embedder that a lost context was received. In response, the embedder might
    38123812        // decide to take action such as asking the user for permission to use WebGL again.
    3813         if (Frame* frame = canvas()->document().frame())
     3813        if (Frame* frame = canvas().document().frame())
    38143814            frame->loader().client().didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());
    38153815    }
    … …  
    44354435void WebGLRenderingContextBase::printWarningToConsole(const String& message)
    44364436{
    4437     if (!canvas())
    4438         return;
    4439     canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);
     4437    canvas().document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);
    44404438}
    44414439
    … …  
    47814779{
    47824780    Ref<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, emptyString());
    4783     canvas()->dispatchEvent(event);
     4781    canvas().dispatchEvent(event);
    47844782    m_restoreAllowed = event->defaultPrevented();
    47854783    if (m_contextLostMode == RealLostContext && m_restoreAllowed)
    … …  
    48294827    }
    48304828
    4831     Frame* frame = canvas()->document().frame();
     4829    Frame* frame = canvas().document().frame();
    48324830    if (!frame)
    48334831        return;
    … …  
    48614859    initializeNewContext();
    48624860    initializeVertexArrayObjects();
    4863     canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, emptyString()));
     4861    canvas().dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, emptyString()));
    48644862}
    48654863
    … …  
    49744972IntSize WebGLRenderingContextBase::clampedCanvasSize()
    49754973{
    4976     return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),
    4977                    clamp(canvas()->height(), 1, m_maxViewportDims[1]));
     4974    return IntSize(clamp(canvas().width(), 1, m_maxViewportDims[0]),
     4975        clamp(canvas().height(), 1, m_maxViewportDims[1]));
    49784976}
    49794977

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.h

    r208032 r208206  
    109109class WebGLRenderingContextBase : public CanvasRenderingContext, public ActiveDOMObject {
    110110public:
    111     static std::unique_ptr<WebGLRenderingContextBase> create(HTMLCanvasElement*, WebGLContextAttributes*, const String&);
     111    static std::unique_ptr<WebGLRenderingContextBase> create(HTMLCanvasElement&, WebGLContextAttributes*, const String&);
    112112    virtual ~WebGLRenderingContextBase();
    113113
    … …  
    335335
    336336protected:
    337     WebGLRenderingContextBase(HTMLCanvasElement*, GraphicsContext3D::Attributes);
    338     WebGLRenderingContextBase(HTMLCanvasElement*, RefPtr<GraphicsContext3D>&&, GraphicsContext3D::Attributes);
     337    WebGLRenderingContextBase(HTMLCanvasElement&, GraphicsContext3D::Attributes);
     338    WebGLRenderingContextBase(HTMLCanvasElement&, RefPtr<GraphicsContext3D>&&, GraphicsContext3D::Attributes);
    339339
    340340    friend class WebGLDrawBuffers;
Note: See TracChangeset for help on using the changeset viewer.