Move HTML canvas and tracks from ExceptionCode to Exception
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 23 Oct 2016 01:05:07 +0000 (01:05 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 23 Oct 2016 01:05:07 +0000 (01:05 +0000)
https://bugs.webkit.org/show_bug.cgi?id=163853

Reviewed by Chris Dumez.

Source/WebCore:

* WebCore.xcodeproj/project.pbxproj: Added CanvasPath.idl.

* bindings/js/JSWebGL2RenderingContextCustom.cpp: Tweaked a bit.

* bindings/js/JSWebGLRenderingContextBaseCustom.cpp:
(WebCore::JSWebGLRenderingContextBase::getExtension): Tweaked a bit.
(WebCore::JSWebGLRenderingContextBase::getFramebufferAttachmentParameter):
Removed unneeded exception handling.
(WebCore::JSWebGLRenderingContextBase::getParameter): Ditto.
(WebCore::JSWebGLRenderingContextBase::getProgramParameter): Ditto.
(WebCore::JSWebGLRenderingContextBase::getShaderParameter): Ditto.
(WebCore::JSWebGLRenderingContextBase::getSupportedExtensions): Use a
modern for loop.
(WebCore::JSWebGLRenderingContextBase::getUniform): Removed unneeded
exception handling.

* html/HTMLCanvasElement.cpp:
(WebCore::HTMLCanvasElement::getContext): Pass a reference.
(WebCore::HTMLCanvasElement::reset): Use is<CanvasRenderingContext2D>.
(WebCore::HTMLCanvasElement::setUsesDisplayListDrawing): Ditto.
(WebCore::HTMLCanvasElement::setTracksDisplayListReplay) Ditto.:
(WebCore::HTMLCanvasElement::displayListAsText): Ditto.
(WebCore::HTMLCanvasElement::replayDisplayListAsText): Ditto.
(WebCore::HTMLCanvasElement::clearImageBuffer): Ditto.

* html/canvas/CanvasGradient.cpp:
(WebCore::CanvasGradient::CanvasGradient): Streamlined.
(WebCore::CanvasGradient::addColorStop): Use ExceptionOr.
* html/canvas/CanvasGradient.h: Updated for above changes.
* html/canvas/CanvasGradient.idl: Use non-legacy exception.

* html/canvas/CanvasPath.cpp:
(WebCore::CanvasPath::arcTo): Use ExceptionOr.
(WebCore::CanvasPath::arc): Ditto.
(WebCore::CanvasPath::ellipse): Ditto.
* html/canvas/CanvasPath.h: Updated for above changes.
* html/canvas/CanvasPath.idl: Use non-legacy exceptions.

* html/canvas/CanvasPattern.cpp:
(WebCore::CanvasPattern::create): Use Ref&&.
(WebCore::CanvasPattern::CanvasPattern): Ditto.
(WebCore::CanvasPattern::parseRepetitionType): Return a boolean
instead of using an ExceptionCode.
* html/canvas/CanvasPattern.h: Updated for above changes.

* html/canvas/CanvasRenderingContext.cpp:
(CanvasRenderingContext::wouldTaintOrigin): Reordered function so
that it's safe to call it on an image element without a cached
image, or a cached image without an underlying image.

* html/canvas/CanvasRenderingContext2D.cpp:
(WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
Take a reference.
(WebCore::CanvasRenderingContext2D::drawImage): Use ExceptionOr.
(WebCore::CanvasRenderingContext2D::drawImageFromRect): Ditto.
(WebCore::CanvasRenderingContext2D::createLinearGradient): Ditto.
(WebCore::CanvasRenderingContext2D::createRadialGradient): Ditto.
(WebCore::CanvasRenderingContext2D::createPattern): Ditto.
(WebCore::CanvasRenderingContext2D::createImageData): Ditto.
(WebCore::CanvasRenderingContext2D::getImageData): Ditto.
(WebCore::CanvasRenderingContext2D::webkitGetImageDataHD): Ditto.
(WebCore::CanvasRenderingContext2D::putImageData): Removed unneeded
ExceptionCode because this does not throw exceptions; the only one
was for non-finite numeric values but this is now handled by bindings.
(WebCore::CanvasRenderingContext2D::webkitPutImageDataHD): Ditto.
* html/canvas/CanvasRenderingContext2D.h: Updated for above.
* html/canvas/CanvasRenderingContext2D.idl: Use non-legacy exceptions
and removed exceptions entirely in other cases.

* html/canvas/OESVertexArrayObject.cpp:
(WebCore::OESVertexArrayObject::OESVertexArrayObject): Take a reference.
(WebCore::OESVertexArrayObject::~OESVertexArrayObject): Deleted.
(WebCore::OESVertexArrayObject::isVertexArrayOES): Use && instead of
multiple return statements.
(WebCore::OESVertexArrayObject::bindVertexArrayOES): Removed unneeded
ExceptionCode since this does not throw an exception.
* html/canvas/OESVertexArrayObject.h: Updated for above.
* html/canvas/OESVertexArrayObject.idl: Removed unneeded exception.

* html/canvas/WebGL2RenderingContext.cpp:
(WebCore::WebGL2RenderingContext::getFramebufferAttachmentParameter):
Removed unneeded ExceptionCode since this does not throw an exception.
(WebCore::WebGL2RenderingContext::texSubImage2DBase): Ditto.
(WebCore::WebGL2RenderingContext::texSubImage2DImpl): Ditto.
(WebCore::WebGL2RenderingContext::texSubImage2D): Removed unneeded
ExceptionCode for some overloads, for the others, use ExceptionOr
for the security exception. Moved security exception code here from
the validate functions.
(WebCore::WebGL2RenderingContext::validateTexFuncParameters): Removed
unneeded ExceptionCode.
(WebCore::WebGL2RenderingContext::getParameter): Ditto.
* html/canvas/WebGL2RenderingContext.h: Updated for above.

* html/canvas/WebGLRenderingContext.cpp:
(WebCore::WebGLRenderingContext::getExtension): Pass a reference.
(WebCore::WebGLRenderingContext::getFramebufferAttachmentParameter):
Remvoed unneeded ExceptionCode since this does not throw an exception.
(WebCore::WebGLRenderingContext::texSubImage2DBase): Ditto.
(WebCore::WebGLRenderingContext::texSubImage2DImpl): Ditto.
(WebCore::WebGLRenderingContext::texSubImage2D): Removed unneeded
ExceptionCode for some overloads, for the others, use ExceptionOr
for the security exception. Moved security exception code here from
the validate functions.
(WebCore::WebGLRenderingContext::getParameter): Removed unneeded
ExceptionCode.
* html/canvas/WebGLRenderingContext.h: Updated for above changes.

* html/canvas/WebGLRenderingContextBase.cpp:
(WebCore::WebGLRenderingContextBase::texImage2DBase):
Remvoed unneeded ExceptionCode since this does not throw an exception.
(WebCore::WebGLRenderingContextBase::texImage2DImpl): Ditto.
(WebCore::WebGLRenderingContextBase::texImage2D): Removed unneeded
ExceptionCode for some overloads, for the others, use ExceptionOr
for the security exception. Moved security exception code here from
the validate functions.
(WebCore::WebGLRenderingContextBase::validateHTMLImageElement):
Moved the security exception out of here to the call sites.
(WebCore::WebGLRenderingContextBase::validateHTMLCanvasElement): Ditto.
(WebCore::WebGLRenderingContextBase::validateHTMLVideoElement): Ditto.
* html/canvas/WebGLRenderingContextBase.h: Updated for above changes.
* html/canvas/WebGLRenderingContextBase.idl: Use non-legacy exceptions
in some cases and no exceptions at all in many others.

* html/shadow/MediaControlElements.cpp:
(WebCore::MediaControlTextTrackContainerElement::updateDisplay):
Use a reference instead of a pointer.

* html/track/DataCue.h: Use pragma once.
* html/track/DataCue.idl: Use non-legacy exception for constructor
attribute, even though it is custom and so it has no effect.

* html/track/InbandDataTextTrack.cpp:
(WebCore::InbandDataTextTrack::create): Use RefPtr&&.
(WebCore::InbandDataTextTrack::InbandDataTextTrack): Ditto.
(WebCore::InbandDataTextTrack::addDataCue): Stop using
ASSERT_NO_EXCEPTION.
(WebCore::InbandDataTextTrack::removeDataCue): Stop using
IGNORE_EXCEPTION.
(WebCore::InbandDataTextTrack::removeCue): Use ExceptionOr.
Also use remove instead of find/remove.
* html/track/InbandDataTextTrack.h: Updated for above changes.

* html/track/InbandGenericTextTrack.cpp:
(WebCore::GenericTextTrackCueMap::GenericTextTrackCueMap): Deleted.
(WebCore::GenericTextTrackCueMap::~GenericTextTrackCueMap): Deleted.
(WebCore::GenericTextTrackCueMap::add): Take references intead of
pointers.
(WebCore::GenericTextTrackCueMap::find): Ditto. Also use get
instead of find.
(WebCore::GenericTextTrackCueMap::remove): Ditto. Also use take
instead of double hashing to both find and remove.
(WebCore::InbandGenericTextTrack::updateCueFromCueData): Stop using
IGNORE_EXCEPTION. Also got rid of code that is converting a double
to a long and then back to a double by using lround. Instead just
use std::round, which keeps it a double. But also, why does this need
to round?!
(WebCore::InbandGenericTextTrack::addGenericCue): Updated to use
reference to work with m_cueMap.
(WebCore::InbandGenericTextTrack::updateGenericCue): Ditto.
(WebCore::InbandGenericTextTrack::removeGenericCue): Ditto.
(WebCore::InbandGenericTextTrack::removeCue): Use ExceptionOr.
(WebCore::InbandGenericTextTrack::newCuesParsed): Removed
ASSERT_NO_EXCEPTION.
* html/track/InbandGenericTextTrack.h: Updated for above changes.

* html/track/InbandWebVTTTextTrack.cpp:
(WebCore::InbandWebVTTTextTrack::newCuesParsed): Removed
ASSERT_NO_EXCEPTION.

* html/track/TextTrack.cpp:
(WebCore::TextTrack::addCue): Use ExcepctionOr.
(WebCore::TextTrack::removeCue): Ditto.
(WebCore::TextTrack::addRegion): Ditto.
(WebCore::TextTrack::removeRegion): Ditto.
* html/track/TextTrack.h: Updated for above changes.
* html/track/TextTrack.idl: Ditto.

* html/track/TextTrackCue.cpp:
(WebCore::TextTrackCue::cueShadowPseudoId): Moved this here
since it does not need to be inlined in the header.
(WebCore::TextTrackCue::~TextTrackCue): Deleted.
(WebCore::TextTrackCue::setStartTime): Removed ExceptionCode&
since the exceptions were for non-finite values, but this is
now handled by the bindings.
(WebCore::TextTrackCue::setEndTime): Ditto.
* html/track/TextTrackCue.h: Updated for the above.
* html/track/TextTrackCue.idl: Removed SetterMayThrowLegacyException
and made startTime and endTime be double rather than unrestricted double.

* html/track/TextTrackCueGeneric.cpp:
(WebCore::TextTrackCueGenericBoxElement::applyCSSProperties):
Use a reference instead of a pointer.
(WebCore::TextTrackCueGeneric::TextTrackCueGeneric): Initialize
m_defaultPosition in the class definition instead of here.
(WebCore::TextTrackCueGeneric::createDisplayTree): Return a Ref.
(WebCore::TextTrackCueGeneric::setLine): Use ExceptionOr.
(WebCore::TextTrackCueGeneric::setPosition): Ditto.
(WebCore::TextTrackCueGeneric::setFontSize): Updated since
displayTreeInternal() now returns a reference.
* html/track/TextTrackCueGeneric.h: Updated for above changes.
Also fixed some arguument types and made some more things private.

* html/track/VTTCue.cpp:
(WebCore::VTTCue::createDisplayTree): Return a Ref.
(WebCore::VTTCue::displayTreeInternal): Return a reference.
(WebCore::VTTCue::setVertical): Use ExceptionOr.
(WebCore::VTTCue::setLine): Ditto.
(WebCore::VTTCue::setPosition): Ditto.
(WebCore::VTTCue::setSize): Ditto.
(WebCore::VTTCue::setAlign): Ditto.
(WebCore::VTTCue::getDisplayTree): Return a reference.
(WebCore::VTTCue::removeDisplayTree): Updated since
displayTreeInternal returns a reference.
(WebCore::VTTCue::setFontSize): Ditto.
* html/track/VTTCue.h: Updated for the above.
* html/track/VTTCue.idl: Use non-legacy exceptions and also
restricted doubles.

* html/track/VTTRegion.cpp:
(WebCore::VTTRegion::VTTRegion): Moved default values all into
the class definition.
(WebCore::VTTRegion::setWidth): Removed the check for non-finite
since the bindings now handle that. Use ExcpetionOr.
(WebCore::VTTRegion::setHeight): Ditto.
(WebCore::VTTRegion::setRegionAnchorX): Ditto.
(WebCore::VTTRegion::setRegionAnchorY): Ditto.
(WebCore::VTTRegion::setViewportAnchorX): Ditto.
(WebCore::VTTRegion::setViewportAnchorY): Ditto.
(WebCore::upKeyword): Added. Shared by the code below.
(WebCore::VTTRegion::scroll): Rewrote to be simpler.
(WebCore::VTTRegion::setScroll): Rewrote to be simpler.
(WebCore::VTTRegion::updateParametersFromRegion): Read and
write data members directly to avoid awkward code that is otherwise
required just to copy from one object to the other. Also take a
const& instead of a pointer for the thing to update from.
(WebCore::VTTRegion::parseSettingValue): Use upKeyword.
(WebCore::VTTRegion::appendTextTrackCueBox): Take a Ref&&.
(WebCore::VTTRegion::getDisplayTree): Do the downcast to Document
here instead of using the helper function.
(WebCore::VTTRegion::prepareRegionDisplayTree): Ditto.
* html/track/VTTRegion.h: Updated for the above.
* html/track/VTTRegion.idl: Use non-legacy exceptions and also
use restricted dobules, not unrestricted.

LayoutTests:

* media/track/regions-webvtt/vtt-region-constructor-expected.txt:
Change expectations to expect the more specific TypeError message
that the bindings generate as opposed to the generic ones that the
WebVTT DOM code was generating before.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@207720 268f45cc-cd09-0410-ab3c-d52691b4dbfc

51 files changed:
LayoutTests/ChangeLog
LayoutTests/media/track/regions-webvtt/vtt-region-constructor-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/bindings/js/JSWebGL2RenderingContextCustom.cpp
Source/WebCore/bindings/js/JSWebGLRenderingContextBaseCustom.cpp
Source/WebCore/html/HTMLCanvasElement.cpp
Source/WebCore/html/canvas/CanvasGradient.cpp
Source/WebCore/html/canvas/CanvasGradient.h
Source/WebCore/html/canvas/CanvasGradient.idl
Source/WebCore/html/canvas/CanvasPath.cpp
Source/WebCore/html/canvas/CanvasPath.h
Source/WebCore/html/canvas/CanvasPath.idl
Source/WebCore/html/canvas/CanvasPattern.cpp
Source/WebCore/html/canvas/CanvasPattern.h
Source/WebCore/html/canvas/CanvasRenderingContext.cpp
Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
Source/WebCore/html/canvas/CanvasRenderingContext2D.h
Source/WebCore/html/canvas/CanvasRenderingContext2D.idl
Source/WebCore/html/canvas/OESVertexArrayObject.cpp
Source/WebCore/html/canvas/OESVertexArrayObject.h
Source/WebCore/html/canvas/OESVertexArrayObject.idl
Source/WebCore/html/canvas/WebGL2RenderingContext.cpp
Source/WebCore/html/canvas/WebGL2RenderingContext.h
Source/WebCore/html/canvas/WebGLRenderingContext.cpp
Source/WebCore/html/canvas/WebGLRenderingContext.h
Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
Source/WebCore/html/canvas/WebGLRenderingContextBase.h
Source/WebCore/html/canvas/WebGLRenderingContextBase.idl
Source/WebCore/html/shadow/MediaControlElements.cpp
Source/WebCore/html/track/DataCue.h
Source/WebCore/html/track/DataCue.idl
Source/WebCore/html/track/InbandDataTextTrack.cpp
Source/WebCore/html/track/InbandDataTextTrack.h
Source/WebCore/html/track/InbandGenericTextTrack.cpp
Source/WebCore/html/track/InbandGenericTextTrack.h
Source/WebCore/html/track/InbandWebVTTTextTrack.cpp
Source/WebCore/html/track/TextTrack.cpp
Source/WebCore/html/track/TextTrack.h
Source/WebCore/html/track/TextTrack.idl
Source/WebCore/html/track/TextTrackCue.cpp
Source/WebCore/html/track/TextTrackCue.h
Source/WebCore/html/track/TextTrackCue.idl
Source/WebCore/html/track/TextTrackCueGeneric.cpp
Source/WebCore/html/track/TextTrackCueGeneric.h
Source/WebCore/html/track/VTTCue.cpp
Source/WebCore/html/track/VTTCue.h
Source/WebCore/html/track/VTTCue.idl
Source/WebCore/html/track/VTTRegion.cpp
Source/WebCore/html/track/VTTRegion.h
Source/WebCore/html/track/VTTRegion.idl

index db539d5..b9bdabe 100644 (file)
@@ -1,3 +1,15 @@
+2016-10-22  Darin Adler  <darin@apple.com>
+
+        Move HTML canvas and tracks from ExceptionCode to Exception
+        https://bugs.webkit.org/show_bug.cgi?id=163853
+
+        Reviewed by Chris Dumez.
+
+        * media/track/regions-webvtt/vtt-region-constructor-expected.txt:
+        Change expectations to expect the more specific TypeError message
+        that the bindings generate as opposed to the generic ones that the
+        WebVTT DOM code was generating before.
+
 2016-10-22  Michael Catanzaro  <mcatanzaro@igalia.com>
 
         Unreviewed GTK test gardening
index 9061cbc..6183306 100644 (file)
@@ -53,53 +53,53 @@ EXPECTED (region.width == '100') OK
 
 Invalid percentage value: -Infinity
 RUN(region.viewportAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorX == '0') OK
 RUN(region.viewportAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorY == '100') OK
 RUN(region.regionAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorX == '0') OK
 RUN(region.regionAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorY == '100') OK
 RUN(region.width = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.width == '100') OK
 
 Invalid percentage value: Infinity
 RUN(region.viewportAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorX == '0') OK
 RUN(region.viewportAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorY == '100') OK
 RUN(region.regionAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorX == '0') OK
 RUN(region.regionAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorY == '100') OK
 RUN(region.width = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.width == '100') OK
 
 Invalid percentage value: NaN
 RUN(region.viewportAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorX == '0') OK
 RUN(region.viewportAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.viewportAnchorY == '100') OK
 RUN(region.regionAnchorX = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorX == '0') OK
 RUN(region.regionAnchorY = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.regionAnchorY == '100') OK
 RUN(region.width = invalidPercentageValues[index])
-TypeError: Type error
+TypeError: The provided value is non-finite
 EXPECTED (region.width == '100') OK
 RUN(region.height = -1)
 IndexSizeError (DOM Exception 1): The index is not in the allowed range.
index bf84285..b149783 100644 (file)
@@ -1,3 +1,254 @@
+2016-10-22  Darin Adler  <darin@apple.com>
+
+        Move HTML canvas and tracks from ExceptionCode to Exception
+        https://bugs.webkit.org/show_bug.cgi?id=163853
+
+        Reviewed by Chris Dumez.
+
+        * WebCore.xcodeproj/project.pbxproj: Added CanvasPath.idl.
+
+        * bindings/js/JSWebGL2RenderingContextCustom.cpp: Tweaked a bit.
+
+        * bindings/js/JSWebGLRenderingContextBaseCustom.cpp:
+        (WebCore::JSWebGLRenderingContextBase::getExtension): Tweaked a bit.
+        (WebCore::JSWebGLRenderingContextBase::getFramebufferAttachmentParameter):
+        Removed unneeded exception handling.
+        (WebCore::JSWebGLRenderingContextBase::getParameter): Ditto.
+        (WebCore::JSWebGLRenderingContextBase::getProgramParameter): Ditto.
+        (WebCore::JSWebGLRenderingContextBase::getShaderParameter): Ditto.
+        (WebCore::JSWebGLRenderingContextBase::getSupportedExtensions): Use a
+        modern for loop.
+        (WebCore::JSWebGLRenderingContextBase::getUniform): Removed unneeded
+        exception handling.
+
+        * html/HTMLCanvasElement.cpp:
+        (WebCore::HTMLCanvasElement::getContext): Pass a reference.
+        (WebCore::HTMLCanvasElement::reset): Use is<CanvasRenderingContext2D>.
+        (WebCore::HTMLCanvasElement::setUsesDisplayListDrawing): Ditto.
+        (WebCore::HTMLCanvasElement::setTracksDisplayListReplay) Ditto.:
+        (WebCore::HTMLCanvasElement::displayListAsText): Ditto.
+        (WebCore::HTMLCanvasElement::replayDisplayListAsText): Ditto.
+        (WebCore::HTMLCanvasElement::clearImageBuffer): Ditto.
+
+        * html/canvas/CanvasGradient.cpp:
+        (WebCore::CanvasGradient::CanvasGradient): Streamlined.
+        (WebCore::CanvasGradient::addColorStop): Use ExceptionOr.
+        * html/canvas/CanvasGradient.h: Updated for above changes.
+        * html/canvas/CanvasGradient.idl: Use non-legacy exception.
+
+        * html/canvas/CanvasPath.cpp:
+        (WebCore::CanvasPath::arcTo): Use ExceptionOr.
+        (WebCore::CanvasPath::arc): Ditto.
+        (WebCore::CanvasPath::ellipse): Ditto.
+        * html/canvas/CanvasPath.h: Updated for above changes.
+        * html/canvas/CanvasPath.idl: Use non-legacy exceptions.
+
+        * html/canvas/CanvasPattern.cpp:
+        (WebCore::CanvasPattern::create): Use Ref&&.
+        (WebCore::CanvasPattern::CanvasPattern): Ditto.
+        (WebCore::CanvasPattern::parseRepetitionType): Return a boolean
+        instead of using an ExceptionCode.
+        * html/canvas/CanvasPattern.h: Updated for above changes.
+
+        * html/canvas/CanvasRenderingContext.cpp:
+        (CanvasRenderingContext::wouldTaintOrigin): Reordered function so
+        that it's safe to call it on an image element without a cached
+        image, or a cached image without an underlying image.
+
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
+        Take a reference.
+        (WebCore::CanvasRenderingContext2D::drawImage): Use ExceptionOr.
+        (WebCore::CanvasRenderingContext2D::drawImageFromRect): Ditto.
+        (WebCore::CanvasRenderingContext2D::createLinearGradient): Ditto.
+        (WebCore::CanvasRenderingContext2D::createRadialGradient): Ditto.
+        (WebCore::CanvasRenderingContext2D::createPattern): Ditto.
+        (WebCore::CanvasRenderingContext2D::createImageData): Ditto.
+        (WebCore::CanvasRenderingContext2D::getImageData): Ditto.
+        (WebCore::CanvasRenderingContext2D::webkitGetImageDataHD): Ditto.
+        (WebCore::CanvasRenderingContext2D::putImageData): Removed unneeded
+        ExceptionCode because this does not throw exceptions; the only one
+        was for non-finite numeric values but this is now handled by bindings.
+        (WebCore::CanvasRenderingContext2D::webkitPutImageDataHD): Ditto.
+        * html/canvas/CanvasRenderingContext2D.h: Updated for above.
+        * html/canvas/CanvasRenderingContext2D.idl: Use non-legacy exceptions
+        and removed exceptions entirely in other cases.
+
+        * html/canvas/OESVertexArrayObject.cpp:
+        (WebCore::OESVertexArrayObject::OESVertexArrayObject): Take a reference.
+        (WebCore::OESVertexArrayObject::~OESVertexArrayObject): Deleted.
+        (WebCore::OESVertexArrayObject::isVertexArrayOES): Use && instead of
+        multiple return statements.
+        (WebCore::OESVertexArrayObject::bindVertexArrayOES): Removed unneeded
+        ExceptionCode since this does not throw an exception.
+        * html/canvas/OESVertexArrayObject.h: Updated for above.
+        * html/canvas/OESVertexArrayObject.idl: Removed unneeded exception.
+
+        * html/canvas/WebGL2RenderingContext.cpp:
+        (WebCore::WebGL2RenderingContext::getFramebufferAttachmentParameter):
+        Removed unneeded ExceptionCode since this does not throw an exception.
+        (WebCore::WebGL2RenderingContext::texSubImage2DBase): Ditto.
+        (WebCore::WebGL2RenderingContext::texSubImage2DImpl): Ditto.
+        (WebCore::WebGL2RenderingContext::texSubImage2D): Removed unneeded
+        ExceptionCode for some overloads, for the others, use ExceptionOr
+        for the security exception. Moved security exception code here from
+        the validate functions.
+        (WebCore::WebGL2RenderingContext::validateTexFuncParameters): Removed
+        unneeded ExceptionCode.
+        (WebCore::WebGL2RenderingContext::getParameter): Ditto.
+        * html/canvas/WebGL2RenderingContext.h: Updated for above.
+
+        * html/canvas/WebGLRenderingContext.cpp:
+        (WebCore::WebGLRenderingContext::getExtension): Pass a reference.
+        (WebCore::WebGLRenderingContext::getFramebufferAttachmentParameter):
+        Remvoed unneeded ExceptionCode since this does not throw an exception.
+        (WebCore::WebGLRenderingContext::texSubImage2DBase): Ditto.
+        (WebCore::WebGLRenderingContext::texSubImage2DImpl): Ditto.
+        (WebCore::WebGLRenderingContext::texSubImage2D): Removed unneeded
+        ExceptionCode for some overloads, for the others, use ExceptionOr
+        for the security exception. Moved security exception code here from
+        the validate functions.
+        (WebCore::WebGLRenderingContext::getParameter): Removed unneeded
+        ExceptionCode.
+        * html/canvas/WebGLRenderingContext.h: Updated for above changes.
+
+        * html/canvas/WebGLRenderingContextBase.cpp:
+        (WebCore::WebGLRenderingContextBase::texImage2DBase):
+        Remvoed unneeded ExceptionCode since this does not throw an exception.
+        (WebCore::WebGLRenderingContextBase::texImage2DImpl): Ditto.
+        (WebCore::WebGLRenderingContextBase::texImage2D): Removed unneeded
+        ExceptionCode for some overloads, for the others, use ExceptionOr
+        for the security exception. Moved security exception code here from
+        the validate functions.
+        (WebCore::WebGLRenderingContextBase::validateHTMLImageElement):
+        Moved the security exception out of here to the call sites.
+        (WebCore::WebGLRenderingContextBase::validateHTMLCanvasElement): Ditto.
+        (WebCore::WebGLRenderingContextBase::validateHTMLVideoElement): Ditto.
+        * html/canvas/WebGLRenderingContextBase.h: Updated for above changes.
+        * html/canvas/WebGLRenderingContextBase.idl: Use non-legacy exceptions
+        in some cases and no exceptions at all in many others.
+
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlTextTrackContainerElement::updateDisplay):
+        Use a reference instead of a pointer.
+
+        * html/track/DataCue.h: Use pragma once.
+        * html/track/DataCue.idl: Use non-legacy exception for constructor
+        attribute, even though it is custom and so it has no effect.
+
+        * html/track/InbandDataTextTrack.cpp:
+        (WebCore::InbandDataTextTrack::create): Use RefPtr&&.
+        (WebCore::InbandDataTextTrack::InbandDataTextTrack): Ditto.
+        (WebCore::InbandDataTextTrack::addDataCue): Stop using
+        ASSERT_NO_EXCEPTION.
+        (WebCore::InbandDataTextTrack::removeDataCue): Stop using
+        IGNORE_EXCEPTION.
+        (WebCore::InbandDataTextTrack::removeCue): Use ExceptionOr.
+        Also use remove instead of find/remove.
+        * html/track/InbandDataTextTrack.h: Updated for above changes.
+
+        * html/track/InbandGenericTextTrack.cpp:
+        (WebCore::GenericTextTrackCueMap::GenericTextTrackCueMap): Deleted.
+        (WebCore::GenericTextTrackCueMap::~GenericTextTrackCueMap): Deleted.
+        (WebCore::GenericTextTrackCueMap::add): Take references intead of
+        pointers.
+        (WebCore::GenericTextTrackCueMap::find): Ditto. Also use get
+        instead of find.
+        (WebCore::GenericTextTrackCueMap::remove): Ditto. Also use take
+        instead of double hashing to both find and remove.
+        (WebCore::InbandGenericTextTrack::updateCueFromCueData): Stop using
+        IGNORE_EXCEPTION. Also got rid of code that is converting a double
+        to a long and then back to a double by using lround. Instead just
+        use std::round, which keeps it a double. But also, why does this need
+        to round?!
+        (WebCore::InbandGenericTextTrack::addGenericCue): Updated to use
+        reference to work with m_cueMap.
+        (WebCore::InbandGenericTextTrack::updateGenericCue): Ditto.
+        (WebCore::InbandGenericTextTrack::removeGenericCue): Ditto.
+        (WebCore::InbandGenericTextTrack::removeCue): Use ExceptionOr.
+        (WebCore::InbandGenericTextTrack::newCuesParsed): Removed
+        ASSERT_NO_EXCEPTION.
+        * html/track/InbandGenericTextTrack.h: Updated for above changes.
+
+        * html/track/InbandWebVTTTextTrack.cpp:
+        (WebCore::InbandWebVTTTextTrack::newCuesParsed): Removed
+        ASSERT_NO_EXCEPTION.
+
+        * html/track/TextTrack.cpp:
+        (WebCore::TextTrack::addCue): Use ExcepctionOr.
+        (WebCore::TextTrack::removeCue): Ditto.
+        (WebCore::TextTrack::addRegion): Ditto.
+        (WebCore::TextTrack::removeRegion): Ditto.
+        * html/track/TextTrack.h: Updated for above changes.
+        * html/track/TextTrack.idl: Ditto.
+
+        * html/track/TextTrackCue.cpp:
+        (WebCore::TextTrackCue::cueShadowPseudoId): Moved this here
+        since it does not need to be inlined in the header.
+        (WebCore::TextTrackCue::~TextTrackCue): Deleted.
+        (WebCore::TextTrackCue::setStartTime): Removed ExceptionCode&
+        since the exceptions were for non-finite values, but this is
+        now handled by the bindings.
+        (WebCore::TextTrackCue::setEndTime): Ditto.
+        * html/track/TextTrackCue.h: Updated for the above.
+        * html/track/TextTrackCue.idl: Removed SetterMayThrowLegacyException
+        and made startTime and endTime be double rather than unrestricted double.
+
+        * html/track/TextTrackCueGeneric.cpp:
+        (WebCore::TextTrackCueGenericBoxElement::applyCSSProperties):
+        Use a reference instead of a pointer.
+        (WebCore::TextTrackCueGeneric::TextTrackCueGeneric): Initialize
+        m_defaultPosition in the class definition instead of here.
+        (WebCore::TextTrackCueGeneric::createDisplayTree): Return a Ref.
+        (WebCore::TextTrackCueGeneric::setLine): Use ExceptionOr.
+        (WebCore::TextTrackCueGeneric::setPosition): Ditto.
+        (WebCore::TextTrackCueGeneric::setFontSize): Updated since
+        displayTreeInternal() now returns a reference.
+        * html/track/TextTrackCueGeneric.h: Updated for above changes.
+        Also fixed some arguument types and made some more things private.
+
+        * html/track/VTTCue.cpp:
+        (WebCore::VTTCue::createDisplayTree): Return a Ref.
+        (WebCore::VTTCue::displayTreeInternal): Return a reference.
+        (WebCore::VTTCue::setVertical): Use ExceptionOr.
+        (WebCore::VTTCue::setLine): Ditto.
+        (WebCore::VTTCue::setPosition): Ditto.
+        (WebCore::VTTCue::setSize): Ditto.
+        (WebCore::VTTCue::setAlign): Ditto.
+        (WebCore::VTTCue::getDisplayTree): Return a reference.
+        (WebCore::VTTCue::removeDisplayTree): Updated since
+        displayTreeInternal returns a reference.
+        (WebCore::VTTCue::setFontSize): Ditto.
+        * html/track/VTTCue.h: Updated for the above.
+        * html/track/VTTCue.idl: Use non-legacy exceptions and also
+        restricted doubles.
+
+        * html/track/VTTRegion.cpp:
+        (WebCore::VTTRegion::VTTRegion): Moved default values all into
+        the class definition.
+        (WebCore::VTTRegion::setWidth): Removed the check for non-finite
+        since the bindings now handle that. Use ExcpetionOr.
+        (WebCore::VTTRegion::setHeight): Ditto.
+        (WebCore::VTTRegion::setRegionAnchorX): Ditto.
+        (WebCore::VTTRegion::setRegionAnchorY): Ditto.
+        (WebCore::VTTRegion::setViewportAnchorX): Ditto.
+        (WebCore::VTTRegion::setViewportAnchorY): Ditto.
+        (WebCore::upKeyword): Added. Shared by the code below.
+        (WebCore::VTTRegion::scroll): Rewrote to be simpler.
+        (WebCore::VTTRegion::setScroll): Rewrote to be simpler.
+        (WebCore::VTTRegion::updateParametersFromRegion): Read and
+        write data members directly to avoid awkward code that is otherwise
+        required just to copy from one object to the other. Also take a
+        const& instead of a pointer for the thing to update from.
+        (WebCore::VTTRegion::parseSettingValue): Use upKeyword.
+        (WebCore::VTTRegion::appendTextTrackCueBox): Take a Ref&&.
+        (WebCore::VTTRegion::getDisplayTree): Do the downcast to Document
+        here instead of using the helper function.
+        (WebCore::VTTRegion::prepareRegionDisplayTree): Ditto.
+        * html/track/VTTRegion.h: Updated for the above.
+        * html/track/VTTRegion.idl: Use non-legacy exceptions and also
+        use restricted dobules, not unrestricted.
+
 2016-10-22  Chris Dumez  <cdumez@apple.com>
 
         WebGLRenderingContextBase.texImage2D() should use a union instead of overloading
index d752094..ae59add 100644 (file)
                935FBC4409BA00B900E230B1 /* EventListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EventListener.h; sourceTree = "<group>"; };
                935FBCF109BA143B00E230B1 /* ExceptionCode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExceptionCode.h; sourceTree = "<group>"; };
                9362640A0DE1137D009D5A00 /* CSSReflectionDirection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSReflectionDirection.h; sourceTree = "<group>"; };
+               936B21F41DBBF8300052E117 /* CanvasPath.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = CanvasPath.idl; sourceTree = "<group>"; };
                936DD03A09CEAC270056AE8C /* Range.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Range.idl; sourceTree = "<group>"; };
                9370918C1416D86B00477333 /* textAreaResizeCorner@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "textAreaResizeCorner@2x.png"; sourceTree = "<group>"; };
                9371080D1DB754550060744E /* WindowOrWorkerGlobalScope.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WindowOrWorkerGlobalScope.idl; sourceTree = "<group>"; };
                                49484FB5102CF23C00187DD3 /* CanvasGradient.idl */,
                                4671E0631D67A57B00C6B497 /* CanvasPath.cpp */,
                                4671E0641D67A57B00C6B497 /* CanvasPath.h */,
+                               936B21F41DBBF8300052E117 /* CanvasPath.idl */,
                                49484FB6102CF23C00187DD3 /* CanvasPattern.cpp */,
                                49484FB7102CF23C00187DD3 /* CanvasPattern.h */,
                                49484FB8102CF23C00187DD3 /* CanvasPattern.idl */,
index 64ac579..0b00875 100644 (file)
@@ -24,9 +24,9 @@
  */
 
 #include "config.h"
+#include "JSWebGL2RenderingContext.h"
 
 #if ENABLE(WEBGL) && ENABLE(WEBGL2)
-#include "JSWebGL2RenderingContext.h"
 
 #include <heap/HeapInlines.h>
 #include <runtime/Error.h>
@@ -37,17 +37,18 @@ using namespace JSC;
 
 namespace WebCore {
 
-static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
+// FIXME: There is a duplicate version of this function in JSWebGLRenderingContextBaseCustom.cpp,
+// but it is not exactly the same! We should merge these.
+static JSValue toJS(ExecState* state, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
 {
     switch (info.getType()) {
     case WebGLGetInfo::kTypeBool:
         return jsBoolean(info.getBool());
     case WebGLGetInfo::kTypeBoolArray: {
         MarkedArgumentBuffer list;
-        const auto& values = info.getBoolArray();
-        for (const auto& value : values)
+        for (auto& value : info.getBoolArray())
             list.append(jsBoolean(value));
-        return constructArray(exec, 0, globalObject, list);
+        return constructArray(state, 0, globalObject, list);
     }
     case WebGLGetInfo::kTypeFloat:
         return jsNumber(info.getFloat());
@@ -56,7 +57,7 @@ static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebG
     case WebGLGetInfo::kTypeNull:
         return jsNull();
     case WebGLGetInfo::kTypeString:
-        return jsStringWithCache(exec, info.getString());
+        return jsStringWithCache(state, info.getString());
     case WebGLGetInfo::kTypeUnsignedInt:
         return jsNumber(info.getUnsignedInt());
     case WebGLGetInfo::kTypeInt64:
@@ -72,60 +73,51 @@ void JSWebGL2RenderingContext::visitAdditionalChildren(SlotVisitor& visitor)
     visitor.addOpaqueRoot(&wrapped());
 }
 
-JSValue JSWebGL2RenderingContext::getInternalformatParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getInternalformatParameter(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-JSValue JSWebGL2RenderingContext::getQueryParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getQueryParameter(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-JSValue JSWebGL2RenderingContext::getSamplerParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getSamplerParameter(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-JSValue JSWebGL2RenderingContext::getSyncParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getSyncParameter(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-JSValue JSWebGL2RenderingContext::getIndexedParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getIndexedParameter(ExecState& state)
 {
-    VM& vm = exec.vm();
+    VM& vm = state.vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    if (exec.argumentCount() != 2)
-        return throwException(&exec, scope, createNotEnoughArgumentsError(&exec));
+    if (state.argumentCount() < 2)
+        return throwException(&state, scope, createNotEnoughArgumentsError(&state));
 
-    WebGL2RenderingContext& context = wrapped();
-    unsigned pname = exec.uncheckedArgument(0).toInt32(&exec);
+    unsigned pname = state.uncheckedArgument(0).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    unsigned index = exec.uncheckedArgument(1).toInt32(&exec);
+    unsigned index = state.uncheckedArgument(1).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLGetInfo info = context.getIndexedParameter(pname, index);
-    return toJS(&exec, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getIndexedParameter(pname, index));
 }
 
-JSValue JSWebGL2RenderingContext::getActiveUniformBlockParameter(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getActiveUniformBlockParameter(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-JSValue JSWebGL2RenderingContext::getActiveUniformBlockName(ExecState& exec)
+JSValue JSWebGL2RenderingContext::getActiveUniformBlockName(ExecState&)
 {
-    UNUSED_PARAM(exec);
     return jsUndefined();
 }
 
-
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)
index 57b7a52..65598b3 100644 (file)
@@ -24,9 +24,9 @@
  */
 
 #include "config.h"
+#include "JSWebGLRenderingContextBase.h"
 
 #if ENABLE(WEBGL)
-#include "JSWebGLRenderingContextBase.h"
 
 #include "ANGLEInstancedArrays.h"
 #include "EXTBlendMinMax.h"
@@ -130,6 +130,8 @@ JSValue toJS(ExecState* state, JSDOMGlobalObject* globalObject, WebGLRenderingCo
     return wrap(state, globalObject, object);
 }
     
+// FIXME: There is a duplicate version of this function in JSWebGL2RenderingContextCustom.cpp,
+// but it is not exactly the same! We should merge these.
 static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
 {
     switch (info.getType()) {
@@ -137,9 +139,8 @@ static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebG
         return jsBoolean(info.getBool());
     case WebGLGetInfo::kTypeBoolArray: {
         MarkedArgumentBuffer list;
-        const Vector<bool>& value = info.getBoolArray();
-        for (size_t ii = 0; ii < value.size(); ++ii)
-            list.append(jsBoolean(value[ii]));
+        for (auto& value : info.getBoolArray())
+            list.append(jsBoolean(value));
         return constructArray(exec, 0, globalObject, list);
     }
     case WebGLGetInfo::kTypeFloat:
@@ -184,9 +185,7 @@ static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebG
     }
 }
 
-enum ObjectType {
-    kBuffer, kRenderbuffer, kTexture, kVertexAttrib
-};
+enum ObjectType { kBuffer, kRenderbuffer, kTexture, kVertexAttrib };
 
 static JSValue getObjectParameter(JSWebGLRenderingContextBase* obj, ExecState& state, ObjectType objectType)
 {
@@ -331,11 +330,9 @@ JSValue JSWebGLRenderingContextBase::getExtension(ExecState& state)
     if (state.argumentCount() < 1)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    WebGLRenderingContextBase& context = wrapped();
-    const String name = state.uncheckedArgument(0).toString(&state)->value(&state);
+    String name = state.uncheckedArgument(0).toWTFString(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLExtension* extension = context.getExtension(name);
-    return toJS(&state, globalObject(), extension);
+    return toJS(&state, globalObject(), wrapped().getExtension(name));
 }
 
 JSValue JSWebGLRenderingContextBase::getBufferParameter(ExecState& state)
@@ -351,20 +348,13 @@ JSValue JSWebGLRenderingContextBase::getFramebufferAttachmentParameter(ExecState
     if (state.argumentCount() != 3)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    ExceptionCode ec = 0;
-    WebGLRenderingContextBase& context = wrapped();
     unsigned target = state.uncheckedArgument(0).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
     unsigned attachment = state.uncheckedArgument(1).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
     unsigned pname = state.uncheckedArgument(2).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLGetInfo info = context.getFramebufferAttachmentParameter(target, attachment, pname, ec);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-    return toJS(&state, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getFramebufferAttachmentParameter(target, attachment, pname));
 }
 
 JSValue JSWebGLRenderingContextBase::getParameter(ExecState& state)
@@ -375,16 +365,9 @@ JSValue JSWebGLRenderingContextBase::getParameter(ExecState& state)
     if (state.argumentCount() != 1)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    ExceptionCode ec = 0;
-    WebGLRenderingContextBase& context = wrapped();
     unsigned pname = state.uncheckedArgument(0).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLGetInfo info = context.getParameter(pname, ec);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-    return toJS(&state, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getParameter(pname));
 }
 
 JSValue JSWebGLRenderingContextBase::getProgramParameter(ExecState& state)
@@ -395,19 +378,12 @@ JSValue JSWebGLRenderingContextBase::getProgramParameter(ExecState& state)
     if (state.argumentCount() != 2)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    ExceptionCode ec = 0;
-    WebGLRenderingContextBase& context = wrapped();
     WebGLProgram* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
     if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
         return throwTypeError(&state, scope);
     unsigned pname = state.uncheckedArgument(1).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLGetInfo info = context.getProgramParameter(program, pname);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-    return toJS(&state, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getProgramParameter(program, pname));
 }
 
 JSValue JSWebGLRenderingContextBase::getRenderbufferParameter(ExecState& state)
@@ -423,19 +399,12 @@ JSValue JSWebGLRenderingContextBase::getShaderParameter(ExecState& state)
     if (state.argumentCount() != 2)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    ExceptionCode ec = 0;
-    WebGLRenderingContextBase& context = wrapped();
     if (!state.uncheckedArgument(0).isUndefinedOrNull() && !state.uncheckedArgument(0).inherits(JSWebGLShader::info()))
         return throwTypeError(&state, scope);
     WebGLShader* shader = JSWebGLShader::toWrapped(state.uncheckedArgument(0));
     unsigned pname = state.uncheckedArgument(1).toInt32(&state);
     RETURN_IF_EXCEPTION(scope, JSValue());
-    WebGLGetInfo info = context.getShaderParameter(shader, pname);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-    return toJS(&state, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getShaderParameter(shader, pname));
 }
 
 JSValue JSWebGLRenderingContextBase::getSupportedExtensions(ExecState& state)
@@ -443,10 +412,9 @@ JSValue JSWebGLRenderingContextBase::getSupportedExtensions(ExecState& state)
     WebGLRenderingContextBase& context = wrapped();
     if (context.isContextLost())
         return jsNull();
-    Vector<String> value = context.getSupportedExtensions();
     MarkedArgumentBuffer list;
-    for (size_t ii = 0; ii < value.size(); ++ii)
-        list.append(jsStringWithCache(&state, value[ii]));
+    for (auto& extension : context.getSupportedExtensions())
+        list.append(jsStringWithCache(&state, extension));
     return constructArray(&state, 0, globalObject(), list);
 }
 
@@ -463,20 +431,13 @@ JSValue JSWebGLRenderingContextBase::getUniform(ExecState& state)
     if (state.argumentCount() != 2)
         return throwException(&state, scope, createNotEnoughArgumentsError(&state));
     
-    ExceptionCode ec = 0;
-    WebGLRenderingContextBase& context = wrapped();
     WebGLProgram* program = JSWebGLProgram::toWrapped(state.uncheckedArgument(0));
     if (!program && !state.uncheckedArgument(0).isUndefinedOrNull())
         return throwTypeError(&state, scope);
     WebGLUniformLocation* location = JSWebGLUniformLocation::toWrapped(state.uncheckedArgument(1));
     if (!location && !state.uncheckedArgument(1).isUndefinedOrNull())
         return throwTypeError(&state, scope);
-    WebGLGetInfo info = context.getUniform(program, location);
-    if (ec) {
-        setDOMException(&state, ec);
-        return jsUndefined();
-    }
-    return toJS(&state, globalObject(), info);
+    return toJS(&state, globalObject(), wrapped().getUniform(program, location));
 }
 
 JSValue JSWebGLRenderingContextBase::getVertexAttrib(ExecState& state)
index 3a3c741..500a196 100644 (file)
@@ -228,7 +228,7 @@ CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, Canvas
                 return nullptr;
             }
 
-            m_context = std::make_unique<CanvasRenderingContext2D>(this, document().inQuirksMode(), usesDashboardCompatibilityMode);
+            m_context = std::make_unique<CanvasRenderingContext2D>(*this, document().inQuirksMode(), usesDashboardCompatibilityMode);
 
             downcast<CanvasRenderingContext2D>(*m_context).setUsesDisplayListDrawing(m_usesDisplayListDrawing);
             downcast<CanvasRenderingContext2D>(*m_context).setTracksDisplayListReplay(m_tracksDisplayListReplay);
@@ -322,10 +322,8 @@ void HTMLCanvasElement::reset()
         m_contextStateSaver->save();
     }
 
-    if (m_context && m_context->is2d()) {
-        CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
-        context2D->reset();
-    }
+    if (is<CanvasRenderingContext2D>(m_context.get()))
+        downcast<CanvasRenderingContext2D>(*m_context).reset();
 
     IntSize oldSize = size();
     IntSize newSize(w, h);
@@ -577,7 +575,7 @@ void HTMLCanvasElement::setUsesDisplayListDrawing(bool usesDisplayListDrawing)
     
     m_usesDisplayListDrawing = usesDisplayListDrawing;
 
-    if (m_context && is<CanvasRenderingContext2D>(*m_context))
+    if (is<CanvasRenderingContext2D>(m_context.get()))
         downcast<CanvasRenderingContext2D>(*m_context).setUsesDisplayListDrawing(m_usesDisplayListDrawing);
 }
 
@@ -588,13 +586,13 @@ void HTMLCanvasElement::setTracksDisplayListReplay(bool tracksDisplayListReplay)
 
     m_tracksDisplayListReplay = tracksDisplayListReplay;
 
-    if (m_context && is<CanvasRenderingContext2D>(*m_context))
+    if (is<CanvasRenderingContext2D>(m_context.get()))
         downcast<CanvasRenderingContext2D>(*m_context).setTracksDisplayListReplay(m_tracksDisplayListReplay);
 }
 
 String HTMLCanvasElement::displayListAsText(DisplayList::AsTextFlags flags) const
 {
-    if (m_context && is<CanvasRenderingContext2D>(*m_context))
+    if (is<CanvasRenderingContext2D>(m_context.get()))
         return downcast<CanvasRenderingContext2D>(*m_context).displayListAsText(flags);
 
     return String();
@@ -602,7 +600,7 @@ String HTMLCanvasElement::displayListAsText(DisplayList::AsTextFlags flags) cons
 
 String HTMLCanvasElement::replayDisplayListAsText(DisplayList::AsTextFlags flags) const
 {
-    if (m_context && is<CanvasRenderingContext2D>(*m_context))
+    if (is<CanvasRenderingContext2D>(m_context.get()))
         return downcast<CanvasRenderingContext2D>(*m_context).replayDisplayListAsText(flags);
 
     return String();
@@ -713,10 +711,9 @@ void HTMLCanvasElement::clearImageBuffer() const
 
     m_didClearImageBuffer = true;
 
-    if (m_context->is2d()) {
-        CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
+    if (is<CanvasRenderingContext2D>(*m_context)) {
         // No need to undo transforms/clip/etc. because we are called right after the context is reset.
-        context2D->clearRect(0, 0, width(), height());
+        downcast<CanvasRenderingContext2D>(*m_context).clearRect(0, 0, width(), height());
     }
 }
 
index d31185a..a5efa32 100644 (file)
 #include "config.h"
 #include "CanvasGradient.h"
 
-#include "CanvasPattern.h"
 #include "CanvasStyle.h"
-#include "CSSParser.h"
 #include "ExceptionCode.h"
 
 namespace WebCore {
 
 CanvasGradient::CanvasGradient(const FloatPoint& p0, const FloatPoint& p1)
     : m_gradient(Gradient::create(p0, p1))
-#if ENABLE(DASHBOARD_SUPPORT)
-    , m_dashboardCompatibilityMode(false)
-#endif
 {
 }
 
 CanvasGradient::CanvasGradient(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1)
     : m_gradient(Gradient::create(p0, r0, p1, r1))
-#if ENABLE(DASHBOARD_SUPPORT)
-    , m_dashboardCompatibilityMode(false)
-#endif
 {
 }
 
-void CanvasGradient::addColorStop(float value, const String& colorString, ExceptionCode& ec)
+ExceptionOr<void> CanvasGradient::addColorStop(float value, const String& colorString)
 {
-    if (!(value >= 0 && value <= 1.0f)) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (!(value >= 0 && value <= 1))
+        return Exception { INDEX_SIZE_ERR };
 
+    // FIXME: Passing null for canvas means this won't work for current color. Is that OK?
     Color color = parseColorOrCurrentColor(colorString, nullptr /*canvas*/);
     if (!color.isValid()) {
 #if ENABLE(DASHBOARD_SUPPORT)
-        if (!m_dashboardCompatibilityMode)
-            ec = SYNTAX_ERR;
-#else
-        ec = SYNTAX_ERR;
+        if (m_dashboardCompatibilityMode)
+            return { };
 #endif
-        return;
+        return Exception { SYNTAX_ERR };
     }
 
     m_gradient->addColorStop(value, color);
+    return { };
 }
 
-} // namespace
+}
index 1211adc..bf75013 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006, 2007, 2008 Apple Inc.  All rights reserved.
+ * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef CanvasGradient_h
-#define CanvasGradient_h
+#pragma once
 
+#include "ExceptionOr.h"
 #include "Gradient.h"
-#include <wtf/Forward.h>
-#include <wtf/RefCounted.h>
 
 namespace WebCore {
 
-    typedef int ExceptionCode;
+class CanvasGradient : public RefCounted<CanvasGradient> {
+public:
+    static Ref<CanvasGradient> create(const FloatPoint& p0, const FloatPoint& p1)
+    {
+        return adoptRef(*new CanvasGradient(p0, p1));
+    }
+    static Ref<CanvasGradient> create(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1)
+    {
+        return adoptRef(*new CanvasGradient(p0, r0, p1, r1));
+    }
 
-    class CanvasGradient : public RefCounted<CanvasGradient> {
-    public:
-        static Ref<CanvasGradient> create(const FloatPoint& p0, const FloatPoint& p1)
-        {
-            return adoptRef(*new CanvasGradient(p0, p1));
-        }
-        static Ref<CanvasGradient> create(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1)
-        {
-            return adoptRef(*new CanvasGradient(p0, r0, p1, r1));
-        }
-        
-        Gradient& gradient() { return m_gradient; }
-        const Gradient& gradient() const { return m_gradient; }
+    Gradient& gradient() { return m_gradient; }
+    const Gradient& gradient() const { return m_gradient; }
 
-        void addColorStop(float value, const String& color, ExceptionCode&);
+    ExceptionOr<void> addColorStop(float value, const String& color);
 
 #if ENABLE(DASHBOARD_SUPPORT)
-        void setDashboardCompatibilityMode() { m_dashboardCompatibilityMode = true; }
+    void setDashboardCompatibilityMode() { m_dashboardCompatibilityMode = true; }
 #endif
 
-    private:
-        CanvasGradient(const FloatPoint& p0, const FloatPoint& p1);
-        CanvasGradient(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1);
-        
-        Ref<Gradient> m_gradient;
+private:
+    CanvasGradient(const FloatPoint& p0, const FloatPoint& p1);
+    CanvasGradient(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1);
+
+    Ref<Gradient> m_gradient;
 #if ENABLE(DASHBOARD_SUPPORT)
-        bool m_dashboardCompatibilityMode;
+    bool m_dashboardCompatibilityMode { false };
 #endif
-    };
-
-} //namespace
+};
 
-#endif
+}
index ccda310..d9c9d09 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006 Apple Inc.  All rights reserved.
+ * Copyright (C) 2006 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -22,9 +22,9 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
+
 [
     ImplementationLacksVTable,
 ] interface CanvasGradient {
-    [MayThrowLegacyException] void addColorStop(float offset, DOMString color);
+    [MayThrowException] void addColorStop(float offset, DOMString color);
 };
-
index 670bae7..a7ff3c9 100644 (file)
@@ -111,19 +111,16 @@ void CanvasPath::bezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y, f
         m_path.addBezierCurveTo(cp1, cp2, p1);
 }
 
-void CanvasPath::arcTo(float x1, float y1, float x2, float y2, float r, ExceptionCode& ec)
+ExceptionOr<void> CanvasPath::arcTo(float x1, float y1, float x2, float y2, float r)
 {
-    ec = 0;
     if (!std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(x2) || !std::isfinite(y2) || !std::isfinite(r))
-        return;
+        return { };
 
-    if (r < 0) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (r < 0)
+        return Exception { INDEX_SIZE_ERR };
 
     if (!hasInvertibleTransform())
-        return;
+        return { };
 
     FloatPoint p1 = FloatPoint(x1, y1);
     FloatPoint p2 = FloatPoint(x2, y2);
@@ -134,6 +131,8 @@ void CanvasPath::arcTo(float x1, float y1, float x2, float y2, float r, Exceptio
         lineTo(x1, y1);
     else
         m_path.addArcTo(p1, p2, r);
+
+    return { };
 }
 
 static void normalizeAngles(float& startAngle, float& endAngle, bool anticlockwise)
@@ -155,42 +154,39 @@ static void normalizeAngles(float& startAngle, float& endAngle, bool anticlockwi
         endAngle = startAngle + 2 * piFloat;
 }
 
-void CanvasPath::arc(float x, float y, float radius, float startAngle, float endAngle, bool anticlockwise, ExceptionCode& ec)
+ExceptionOr<void> CanvasPath::arc(float x, float y, float radius, float startAngle, float endAngle, bool anticlockwise)
 {
     if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radius) || !std::isfinite(startAngle) || !std::isfinite(endAngle))
-        return;
+        return { };
 
-    if (radius < 0) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (radius < 0)
+        return Exception { INDEX_SIZE_ERR };
 
     if (!hasInvertibleTransform())
-        return;
+        return { };
 
     normalizeAngles(startAngle, endAngle, anticlockwise);
 
     if (!radius || startAngle == endAngle) {
         // The arc is empty but we still need to draw the connecting line.
         lineTo(x + radius * cosf(startAngle), y + radius * sinf(startAngle));
-        return;
+        return { };
     }
 
     m_path.addArc(FloatPoint(x, y), radius, startAngle, endAngle, anticlockwise);
+    return { };
 }
     
-void CanvasPath::ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise, ExceptionCode& ec)
+ExceptionOr<void> CanvasPath::ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngle, bool anticlockwise)
 {
     if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radiusX) || !std::isfinite(radiusY) || !std::isfinite(rotation) || !std::isfinite(startAngle) || !std::isfinite(endAngle))
-        return;
+        return { };
 
-    if (radiusX < 0 || radiusY < 0) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (radiusX < 0 || radiusY < 0)
+        return Exception { INDEX_SIZE_ERR };
 
     if (!hasInvertibleTransform())
-        return;
+        return { };
 
     normalizeAngles(startAngle, endAngle, anticlockwise);
 
@@ -199,7 +195,7 @@ void CanvasPath::ellipse(float x, float y, float radiusX, float radiusY, float r
         transform.translate(x, y).rotate(rad2deg(rotation));
 
         lineTo(transform.mapPoint(FloatPoint(radiusX * cosf(startAngle), radiusY * sinf(startAngle))));
-        return;
+        return { };
     }
 
     if (!radiusX || !radiusY) {
@@ -217,10 +213,11 @@ void CanvasPath::ellipse(float x, float y, float radiusX, float radiusY, float r
         }
 
         lineTo(transform.mapPoint(FloatPoint(radiusX * cosf(endAngle), radiusY * sinf(endAngle))));
-        return;
+        return { };
     }
 
     m_path.addEllipse(FloatPoint(x, y), radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+    return { };
 }
 
 void CanvasPath::rect(float x, float y, float width, float height)
index 8a6bf80..e752560 100644 (file)
 
 #pragma once
 
+#include "ExceptionOr.h"
 #include "Path.h"
 
 namespace WebCore {
 
-class FloatRect;
-
-typedef int ExceptionCode;
-
 class CanvasPath {
 public:
     virtual ~CanvasPath() { }
@@ -45,9 +42,9 @@ public:
     void lineTo(float x, float y);
     void quadraticCurveTo(float cpx, float cpy, float x, float y);
     void bezierCurveTo(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y);
-    void arcTo(float x0, float y0, float x1, float y1, float radius, ExceptionCode&);
-    void arc(float x, float y, float r, float sa, float ea, bool anticlockwise, ExceptionCode&);
-    void ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngled, bool anticlockwise, ExceptionCode&);
+    ExceptionOr<void> arcTo(float x0, float y0, float x1, float y1, float radius);
+    ExceptionOr<void> arc(float x, float y, float r, float sa, float ea, bool anticlockwise);
+    ExceptionOr<void> ellipse(float x, float y, float radiusX, float radiusY, float rotation, float startAngle, float endAngled, bool anticlockwise);
     void rect(float x, float y, float width, float height);
 
 protected:
index dbdbd86..da0cc87 100644 (file)
@@ -33,9 +33,9 @@
     void lineTo(unrestricted double x, unrestricted double y);
     void quadraticCurveTo(unrestricted double cpx, unrestricted double cpy, unrestricted double x, unrestricted double y);
     void bezierCurveTo(unrestricted double cp1x, unrestricted double cp1y, unrestricted double cp2x, unrestricted double cp2y, unrestricted double x, unrestricted double y);
-    [MayThrowLegacyException] void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
-    // [MayThrowLegacyException] void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation);
+    [MayThrowException] void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radius);
+    // [MayThrowException] void arcTo(unrestricted double x1, unrestricted double y1, unrestricted double x2, unrestricted double y2, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation);
     void rect(unrestricted double x, unrestricted double y, unrestricted double w, unrestricted double h);
-    [MayThrowLegacyException] void arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
-    [MayThrowLegacyException] void ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
+    [MayThrowException] void arc(unrestricted double x, unrestricted double y, unrestricted double radius, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
+    [MayThrowException] void ellipse(unrestricted double x, unrestricted double y, unrestricted double radiusX, unrestricted double radiusY, unrestricted double rotation, unrestricted double startAngle, unrestricted double endAngle, optional boolean anticlockwise = false);
 };
index 77cdeb2..db6b7e7 100644 (file)
 
 namespace WebCore {
 
-Ref<CanvasPattern> CanvasPattern::create(PassRefPtr<Image> image, bool repeatX, bool repeatY, bool originClean)
+Ref<CanvasPattern> CanvasPattern::create(Ref<Image>&& image, bool repeatX, bool repeatY, bool originClean)
 {
-    return adoptRef(*new CanvasPattern(image, repeatX, repeatY, originClean));
+    return adoptRef(*new CanvasPattern(WTFMove(image), repeatX, repeatY, originClean));
 }
 
-CanvasPattern::CanvasPattern(PassRefPtr<Image> image, bool repeatX, bool repeatY, bool originClean)
-    : m_pattern(Pattern::create(image, repeatX, repeatY))
+CanvasPattern::CanvasPattern(Ref<Image>&& image, bool repeatX, bool repeatY, bool originClean)
+    : m_pattern(Pattern::create(WTFMove(image), repeatX, repeatY))
     , m_originClean(originClean)
 {
 }
@@ -48,30 +48,29 @@ CanvasPattern::~CanvasPattern()
 {
 }
 
-void CanvasPattern::parseRepetitionType(const String& type, bool& repeatX, bool& repeatY, ExceptionCode& ec)
+bool CanvasPattern::parseRepetitionType(const String& type, bool& repeatX, bool& repeatY)
 {
-    ec = 0;
     if (type.isEmpty() || type == "repeat") {
         repeatX = true;
         repeatY = true;
-        return;
+        return true;
     }
     if (type == "no-repeat") {
         repeatX = false;
         repeatY = false;
-        return;
+        return true;
     }
     if (type == "repeat-x") {
         repeatX = true;
         repeatY = false;
-        return;
+        return true;
     }
     if (type == "repeat-y") {
         repeatX = false;
         repeatY = true;
-        return;
+        return true;
     }
-    ec = SYNTAX_ERR;
+    return false;
 }
 
 } // namespace WebCore
index c2a4c28..b8faaab 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef CanvasPattern_h
-#define CanvasPattern_h
+#pragma once
 
 #include <wtf/Forward.h>
-#include <wtf/PassRefPtr.h>
 #include <wtf/Ref.h>
 #include <wtf/RefCounted.h>
 
@@ -36,14 +34,12 @@ namespace WebCore {
 class Image;
 class Pattern;
 
-typedef int ExceptionCode;
-
 class CanvasPattern : public RefCounted<CanvasPattern> {
 public:
-    static Ref<CanvasPattern> create(PassRefPtr<Image>, bool repeatX, bool repeatY, bool originClean);
+    static Ref<CanvasPattern> create(Ref<Image>&&, bool repeatX, bool repeatY, bool originClean);
     ~CanvasPattern();
 
-    static void parseRepetitionType(const String&, bool& repeatX, bool& repeatY, ExceptionCode&);
+    static bool parseRepetitionType(const String&, bool& repeatX, bool& repeatY);
 
     Pattern& pattern() { return m_pattern; }
     const Pattern& pattern() const { return m_pattern; }
@@ -51,12 +47,10 @@ public:
     bool originClean() const { return m_originClean; }
 
 private:
-    CanvasPattern(PassRefPtr<Image>, bool repeatX, bool repeatY, bool originClean);
+    CanvasPattern(Ref<Image>&&, bool repeatX, bool repeatY, bool originClean);
 
     Ref<Pattern> m_pattern;
     bool m_originClean;
 };
 
 } // namespace WebCore
-
-#endif
index 6a3daa7..ccb450a 100644 (file)
@@ -55,22 +55,29 @@ bool CanvasRenderingContext::wouldTaintOrigin(const HTMLCanvasElement* sourceCan
     return false;
 }
 
-bool CanvasRenderingContext::wouldTaintOrigin(const HTMLImageElement* image)
+bool CanvasRenderingContext::wouldTaintOrigin(const HTMLImageElement* element)
 {
-    if (!image || !canvas()->originClean())
+    if (!element || !canvas()->originClean())
         return false;
 
-    ASSERT(image->cachedImage());
-    CachedImage& cachedImage = *image->cachedImage();
+    auto* cachedImage = element->cachedImage();
+    if (!cachedImage)
+        return false;
+
+    auto* image = cachedImage->image();
+    if (!image)
+        return false;
 
-    ASSERT(cachedImage.image());
-    if (!cachedImage.image()->hasSingleSecurityOrigin())
+    if (!image->hasSingleSecurityOrigin())
+        return true;
+
+    if (!cachedImage->isCORSSameOrigin())
         return true;
 
     ASSERT(canvas()->securityOrigin());
-    ASSERT(cachedImage.origin());
-    ASSERT(canvas()->securityOrigin()->toString() == cachedImage.origin()->toString());
-    return !cachedImage.isCORSSameOrigin();
+    ASSERT(cachedImage->origin());
+    ASSERT(canvas()->securityOrigin()->toString() == cachedImage->origin()->toString());
+    return false;
 }
 
 bool CanvasRenderingContext::wouldTaintOrigin(const HTMLVideoElement* video)
index 6c8b852..cd0b041 100644 (file)
@@ -132,8 +132,8 @@ private:
     CanvasRenderingContext2D* m_canvasContext;
 };
 
-CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
-    : CanvasRenderingContext(canvas)
+CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement& canvas, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode)
+    : CanvasRenderingContext(&canvas)
     , m_stateStack(1)
     , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
 #if ENABLE(DASHBOARD_SUPPORT)
@@ -1348,82 +1348,75 @@ static inline FloatRect normalizeRect(const FloatRect& rect)
         std::max(rect.height(), -rect.height()));
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, float x, float y, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, float x, float y)
 {
     LayoutSize destRectSize = size(imageElement, ImageSizeAfterDevicePixelRatio);
-    drawImage(imageElement, x, y, destRectSize.width(), destRectSize.height(), ec);
+    return drawImage(imageElement, x, y, destRectSize.width(), destRectSize.height());
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement,
-    float x, float y, float width, float height, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, float x, float y, float width, float height)
 {
     LayoutSize sourceRectSize = size(imageElement, ImageSizeBeforeDevicePixelRatio);
-    drawImage(imageElement, FloatRect(0, 0, sourceRectSize.width(), sourceRectSize.height()), FloatRect(x, y, width, height), ec);
+    return drawImage(imageElement, FloatRect { 0, 0, sourceRectSize.width(), sourceRectSize.height() }, FloatRect { x, y, width, height });
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)
 {
-    drawImage(imageElement, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec);
+    return drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh });
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect)
 {
-    drawImage(imageElement, srcRect, dstRect, state().globalComposite, state().globalBlend, ec);
+    return drawImage(imageElement, srcRect, dstRect, state().globalComposite, state().globalBlend);
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
 {
-    ec = 0;
-
     if (!std::isfinite(dstRect.x()) || !std::isfinite(dstRect.y()) || !std::isfinite(dstRect.width()) || !std::isfinite(dstRect.height())
         || !std::isfinite(srcRect.x()) || !std::isfinite(srcRect.y()) || !std::isfinite(srcRect.width()) || !std::isfinite(srcRect.height()))
-        return;
+        return { };
 
     if (!dstRect.width() || !dstRect.height())
-        return;
+        return { };
 
     if (!imageElement.complete())
-        return;
+        return { };
 
     FloatRect normalizedSrcRect = normalizeRect(srcRect);
     FloatRect normalizedDstRect = normalizeRect(dstRect);
 
     FloatRect imageRect = FloatRect(FloatPoint(), size(imageElement, ImageSizeBeforeDevicePixelRatio));
-    if (!srcRect.width() || !srcRect.height()) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (!srcRect.width() || !srcRect.height())
+        return Exception { INDEX_SIZE_ERR };
 
     // When the source rectangle is outside the source image, the source rectangle must be clipped
     // to the source image and the destination rectangle must be clipped in the same proportion.
     FloatRect originalNormalizedSrcRect = normalizedSrcRect;
     normalizedSrcRect.intersect(imageRect);
     if (normalizedSrcRect.isEmpty())
-        return;
+        return { };
 
     if (normalizedSrcRect != originalNormalizedSrcRect) {
         normalizedDstRect.setWidth(normalizedDstRect.width() * normalizedSrcRect.width() / originalNormalizedSrcRect.width());
         normalizedDstRect.setHeight(normalizedDstRect.height() * normalizedSrcRect.height() / originalNormalizedSrcRect.height());
         if (normalizedDstRect.isEmpty())
-            return;
+            return { };
     }
 
     GraphicsContext* c = drawingContext();
     if (!c)
-        return;
+        return { };
     if (!state().hasInvertibleTransform)
-        return;
+        return { };
 
     CachedImage* cachedImage = imageElement.cachedImage();
     if (!cachedImage)
-        return;
+        return { };
 
     Image* image = cachedImage->imageForRenderer(imageElement.renderer());
     if (!image)
-        return;
-    
+        return { };
+
     ImageObserver* observer = image->imageObserver();
 
     if (image->isSVGImage()) {
@@ -1450,56 +1443,48 @@ void CanvasRenderingContext2D::drawImage(HTMLImageElement& imageElement, const F
         image->setImageObserver(observer);
 
     checkOrigin(&imageElement);
+
+    return { };
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, float x, float y, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, float x, float y)
 {
-    drawImage(sourceCanvas, 0, 0, sourceCanvas.width(), sourceCanvas.height(), x, y, sourceCanvas.width(), sourceCanvas.height(), ec);
+    return drawImage(sourceCanvas, 0, 0, sourceCanvas.width(), sourceCanvas.height(), x, y, sourceCanvas.width(), sourceCanvas.height());
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas,
-    float x, float y, float width, float height, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, float x, float y, float width, float height)
 {
-    drawImage(sourceCanvas, FloatRect(0, 0, sourceCanvas.width(), sourceCanvas.height()), FloatRect(x, y, width, height), ec);
+    return drawImage(sourceCanvas, FloatRect(0, 0, sourceCanvas.width(), sourceCanvas.height()), FloatRect { x, y, width, height });
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)
 {
-    drawImage(sourceCanvas, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec);
+    return drawImage(sourceCanvas, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh));
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, const FloatRect& srcRect,
-    const FloatRect& dstRect, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, const FloatRect& srcRect, const FloatRect& dstRect)
 {
     FloatRect srcCanvasRect = FloatRect(FloatPoint(), sourceCanvas.size());
 
-    if (!srcCanvasRect.width() || !srcCanvasRect.height()) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
+    if (!srcCanvasRect.width() || !srcCanvasRect.height())
+        return Exception { INVALID_STATE_ERR };
 
-    if (!srcRect.width() || !srcRect.height()) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
-    ec = 0;
+    if (!srcRect.width() || !srcRect.height())
+        return Exception { INDEX_SIZE_ERR };
 
     if (!srcCanvasRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
-        return;
+        return { };
 
     GraphicsContext* c = drawingContext();
     if (!c)
-        return;
+        return { };
     if (!state().hasInvertibleTransform)
-        return;
+        return { };
 
     // FIXME: Do this through platform-independent GraphicsContext API.
     ImageBuffer* buffer = sourceCanvas.buffer();
     if (!buffer)
-        return;
+        return { };
 
     checkOrigin(&sourceCanvas);
 
@@ -1528,51 +1513,46 @@ void CanvasRenderingContext2D::drawImage(HTMLCanvasElement& sourceCanvas, const
         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
         didDraw(dstRect);
     }
+
+    return { };
 }
 
 #if ENABLE(VIDEO)
-void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, float x, float y, ExceptionCode& ec)
+
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, float x, float y)
 {
     FloatSize videoSize = size(video);
-    drawImage(video, x, y, videoSize.width(), videoSize.height(), ec);
+    return drawImage(video, x, y, videoSize.width(), videoSize.height());
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video,
-                                         float x, float y, float width, float height, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, float x, float y, float width, float height)
 {
     FloatSize videoSize = size(video);
-    drawImage(video, FloatRect(0, 0, videoSize.width(), videoSize.height()), FloatRect(x, y, width, height), ec);
+    return drawImage(video, FloatRect { 0, 0, videoSize.width(), videoSize.height() }, FloatRect { x, y, width, height });
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh)
 {
-    drawImage(video, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), ec);
+    return drawImage(video, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh });
 }
 
-void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRect& srcRect, const FloatRect& dstRect,
-                                         ExceptionCode& ec)
+ExceptionOr<void> CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRect& srcRect, const FloatRect& dstRect)
 {
-    ec = 0;
-
     if (video.readyState() == HTMLMediaElement::HAVE_NOTHING || video.readyState() == HTMLMediaElement::HAVE_METADATA)
-        return;
+        return { };
 
     FloatRect videoRect = FloatRect(FloatPoint(), size(video));
-    if (!srcRect.width() || !srcRect.height()) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (!srcRect.width() || !srcRect.height())
+        return Exception { INDEX_SIZE_ERR };
 
     if (!videoRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
-        return;
+        return { };
 
     GraphicsContext* c = drawingContext();
     if (!c)
-        return;
+        return { };
     if (!state().hasInvertibleTransform)
-        return;
+        return { };
 
     checkOrigin(&video);
 
@@ -1584,7 +1564,7 @@ void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRec
         else
             didDraw(dstRect);
 
-        return;
+        return { };
     }
 #endif
 
@@ -1596,20 +1576,19 @@ void CanvasRenderingContext2D::drawImage(HTMLVideoElement& video, const FloatRec
     video.paintCurrentFrameInContext(*c, FloatRect(FloatPoint(), size(video)));
     stateSaver.restore();
     didDraw(dstRect);
+
+    return { };
 }
+
 #endif
 
-void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement,
-    float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh,
-    const String& compositeOperation)
+void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation)
 {
     CompositeOperator op;
     BlendMode blendOp = BlendModeNormal;
     if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal)
         op = CompositeSourceOver;
-
-    drawImage(imageElement, FloatRect(sx, sy, sw, sh), FloatRect(dx, dy, dw, dh), op, BlendModeNormal, IGNORE_EXCEPTION);
+    drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh }, op, BlendModeNormal);
 }
 
 void CanvasRenderingContext2D::setAlpha(float alpha)
@@ -1747,56 +1726,43 @@ void CanvasRenderingContext2D::prepareGradientForDashboard(CanvasGradient& gradi
 #endif
 }
 
-RefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1, ExceptionCode& ec)
+ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
 {
-    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1)) {
-        ec = NOT_SUPPORTED_ERR;
-        return nullptr;
-    }
+    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(x1) || !std::isfinite(y1))
+        return Exception { NOT_SUPPORTED_ERR };
 
     Ref<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     prepareGradientForDashboard(gradient.get());
     return WTFMove(gradient);
 }
 
-RefPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionCode& ec)
+ExceptionOr<Ref<CanvasGradient>> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1)
 {
-    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1)) {
-        ec = NOT_SUPPORTED_ERR;
-        return nullptr;
-    }
+    if (!std::isfinite(x0) || !std::isfinite(y0) || !std::isfinite(r0) || !std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(r1))
+        return Exception { NOT_SUPPORTED_ERR };
 
-    if (r0 < 0 || r1 < 0) {
-        ec = INDEX_SIZE_ERR;
-        return nullptr;
-    }
+    if (r0 < 0 || r1 < 0)
+        return Exception { INDEX_SIZE_ERR };
 
     Ref<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
     prepareGradientForDashboard(gradient.get());
     return WTFMove(gradient);
 }
 
-RefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLImageElement& imageElement,
-    const String& repetitionType, ExceptionCode& ec)
+ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLImageElement& imageElement, const String& repetitionType)
 {
     bool repeatX, repeatY;
-    ec = 0;
-    CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec);
-    if (ec)
-        return nullptr;
+    if (!CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY))
+        return Exception { SYNTAX_ERR };
+
+    auto* cachedImage = imageElement.cachedImage();
 
-    CachedImage* cachedImage = imageElement.cachedImage();
     // If the image loading hasn't started or the image is not complete, it is not fully decodable.
     if (!cachedImage || !imageElement.complete())
         return nullptr;
 
-    if (cachedImage->status() == CachedResource::LoadError) {
-        ec = INVALID_STATE_ERR;
-        return nullptr;
-    }
-
-    if (!imageElement.cachedImage()->imageForRenderer(imageElement.renderer()))
-        return CanvasPattern::create(Image::nullImage(), repeatX, repeatY, true);
+    if (cachedImage->status() == CachedResource::LoadError)
+        return Exception { INVALID_STATE_ERR };
 
     bool originClean = cachedImage->isOriginClean(canvas()->securityOrigin());
 
@@ -1809,50 +1775,46 @@ RefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLImageElement&
     if (cachedImage->image()->isSVGImage())
         originClean = false;
 
-    return CanvasPattern::create(cachedImage->imageForRenderer(imageElement.renderer()), repeatX, repeatY, originClean);
+    return RefPtr<CanvasPattern> { CanvasPattern::create(*cachedImage->imageForRenderer(imageElement.renderer()), repeatX, repeatY, originClean) };
 }
 
-RefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLCanvasElement& canvas,
-    const String& repetitionType, ExceptionCode& ec)
+ExceptionOr<Ref<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLCanvasElement& canvas, const String& repetitionType)
 {
-    if (!canvas.width() || !canvas.height() || !canvas.buffer()) {
-        ec = INVALID_STATE_ERR;
-        return nullptr;
-    }
+    if (!canvas.width() || !canvas.height() || !canvas.buffer())
+        return Exception { INVALID_STATE_ERR };
 
     bool repeatX, repeatY;
-    ec = 0;
-    CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec);
-    if (ec)
-        return nullptr;
-    return CanvasPattern::create(canvas.copiedImage(), repeatX, repeatY, canvas.originClean());
+    if (!CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY))
+        return Exception { SYNTAX_ERR };
+
+    return CanvasPattern::create(*canvas.copiedImage(), repeatX, repeatY, canvas.originClean());
 }
     
 #if ENABLE(VIDEO)
-RefPtr<CanvasPattern> CanvasRenderingContext2D::createPattern(HTMLVideoElement& videoElement, const String& repetitionType, ExceptionCode& ec)
+
+ExceptionOr<RefPtr<CanvasPattern>> CanvasRenderingContext2D::createPattern(HTMLVideoElement& videoElement, const String& repetitionType)
 {
     if (videoElement.readyState() < HTMLMediaElement::HAVE_CURRENT_DATA)
         return nullptr;
     
     bool repeatX, repeatY;
-    ec = 0;
-    CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY, ec);
-    if (ec)
-        return nullptr;
-    
+    if (!CanvasPattern::parseRepetitionType(repetitionType, repeatX, repeatY))
+        return Exception { SYNTAX_ERR };
+
     checkOrigin(&videoElement);
     bool originClean = canvas()->originClean();
 
 #if USE(CG) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(GSTREAMER_GL) && USE(CAIRO))
     if (auto nativeImage = videoElement.nativeImageForCurrentTime())
-        return CanvasPattern::create(BitmapImage::create(WTFMove(nativeImage)), repeatX, repeatY, originClean);
+        return RefPtr<CanvasPattern> { CanvasPattern::create(BitmapImage::create(WTFMove(nativeImage)), repeatX, repeatY, originClean) };
 #endif
 
     auto imageBuffer = ImageBuffer::create(size(videoElement), drawingContext() ? drawingContext()->renderingMode() : Accelerated);
     videoElement.paintCurrentFrameInContext(imageBuffer->context(), FloatRect(FloatPoint(), size(videoElement)));
     
-    return CanvasPattern::create(ImageBuffer::sinkIntoImage(WTFMove(imageBuffer), Unscaled), repeatX, repeatY, originClean);
+    return RefPtr<CanvasPattern> { CanvasPattern::create(ImageBuffer::sinkIntoImage(WTFMove(imageBuffer), Unscaled).releaseNonNull(), repeatX, repeatY, originClean) };
 }
+
 #endif
 
 void CanvasRenderingContext2D::didDrawEntireCanvas()
@@ -1975,29 +1937,20 @@ static RefPtr<ImageData> createEmptyImageData(const IntSize& size)
     return nullptr;
 }
 
-RefPtr<ImageData> CanvasRenderingContext2D::createImageData(RefPtr<ImageData>&& imageData, ExceptionCode& ec) const
+ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(ImageData* imageData) const
 {
-    if (!imageData) {
-        ec = NOT_SUPPORTED_ERR;
-        return nullptr;
-    }
+    if (!imageData)
+        return Exception { NOT_SUPPORTED_ERR };
 
     return createEmptyImageData(imageData->size());
 }
 
-RefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionCode& ec) const
+ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::createImageData(float sw, float sh) const
 {
-    ec = 0;
-    if (!sw || !sh) {
-        ec = INDEX_SIZE_ERR;
-        return nullptr;
-    }
-    if (!std::isfinite(sw) || !std::isfinite(sh)) {
-        ec = TypeError;
-        return nullptr;
-    }
+    if (!sw || !sh)
+        return Exception { INDEX_SIZE_ERR };
 
-    FloatSize logicalSize(fabs(sw), fabs(sh));
+    FloatSize logicalSize(std::abs(sw), std::abs(sh));
     if (!logicalSize.isExpressibleAsIntSize())
         return nullptr;
 
@@ -2010,33 +1963,26 @@ RefPtr<ImageData> CanvasRenderingContext2D::createImageData(float sw, float sh,
     return createEmptyImageData(size);
 }
 
-RefPtr<ImageData> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh, ExceptionCode& ec) const
+ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) const
 {
-    return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh, ec);
+    return getImageData(ImageBuffer::LogicalCoordinateSystem, sx, sy, sw, sh);
 }
 
-RefPtr<ImageData> CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh, ExceptionCode& ec) const
+ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::webkitGetImageDataHD(float sx, float sy, float sw, float sh) const
 {
-    return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh, ec);
+    return getImageData(ImageBuffer::BackingStoreCoordinateSystem, sx, sy, sw, sh);
 }
 
-RefPtr<ImageData> CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh, ExceptionCode& ec) const
+ExceptionOr<RefPtr<ImageData>> CanvasRenderingContext2D::getImageData(ImageBuffer::CoordinateSystem coordinateSystem, float sx, float sy, float sw, float sh) const
 {
     if (!canvas()->originClean()) {
         static NeverDestroyed<String> consoleMessage(ASCIILiteral("Unable to get image data from canvas because the canvas has been tainted by cross-origin data."));
         canvas()->document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
-        ec = SECURITY_ERR;
-        return nullptr;
+        return Exception { SECURITY_ERR };
     }
 
-    if (!sw || !sh) {
-        ec = INDEX_SIZE_ERR;
-        return nullptr;
-    }
-    if (!std::isfinite(sx) || !std::isfinite(sy) || !std::isfinite(sw) || !std::isfinite(sh)) {
-        ec = NOT_SUPPORTED_ERR;
-        return nullptr;
-    }
+    if (!sw || !sh)
+        return Exception { INDEX_SIZE_ERR };
 
     if (sw < 0) {
         sx += sw;
@@ -2060,7 +2006,7 @@ RefPtr<ImageData> CanvasRenderingContext2D::getImageData(ImageBuffer::Coordinate
     if (!buffer)
         return createEmptyImageData(imageDataRect.size());
 
-    RefPtr<Uint8ClampedArray> byteArray = buffer->getUnmultipliedImageData(imageDataRect, coordinateSystem);
+    auto byteArray = buffer->getUnmultipliedImageData(imageDataRect, coordinateSystem);
     if (!byteArray) {
         StringBuilder consoleMessage;
         consoleMessage.appendLiteral("Unable to get image data from canvas. Requested size was ");
@@ -2069,32 +2015,30 @@ RefPtr<ImageData> CanvasRenderingContext2D::getImageData(ImageBuffer::Coordinate
         consoleMessage.appendNumber(imageDataRect.height());
 
         canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Error, consoleMessage.toString());
-        ec = INVALID_STATE_ERR;
-        return nullptr;
+        return Exception { INVALID_STATE_ERR };
     }
 
     return ImageData::create(imageDataRect.size(), byteArray.releaseNonNull());
 }
 
-void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy, ExceptionCode& ec)
+void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy)
 {
-    putImageData(data, dx, dy, 0, 0, data.width(), data.height(), ec);
+    putImageData(data, dx, dy, 0, 0, data.width(), data.height());
 }
 
-void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, ExceptionCode& ec)
+void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy)
 {
-    webkitPutImageDataHD(data, dx, dy, 0, 0, data.width(), data.height(), ec);
+    webkitPutImageDataHD(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, ExceptionCode& ec)
+void CanvasRenderingContext2D::putImageData(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
 {
-    putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight, ec);
+    putImageData(data, ImageBuffer::LogicalCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
 }
 
-void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode& ec)
+void CanvasRenderingContext2D::webkitPutImageDataHD(ImageData& data, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
 {
-    putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight, ec);
+    putImageData(data, ImageBuffer::BackingStoreCoordinateSystem, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)
@@ -2111,21 +2055,14 @@ void CanvasRenderingContext2D::drawFocusIfNeededInternal(const Path& path, Eleme
 {
     GraphicsContext* context = drawingContext();
 
-    if (!element || !element->focused() || !state().hasInvertibleTransform || path.isEmpty()
-        || !element->isDescendantOf(canvas()) || !context)
+    if (!element || !element->focused() || !state().hasInvertibleTransform || path.isEmpty() || !element->isDescendantOf(canvas()) || !context)
         return;
 
     context->drawFocusRing(path, 1, 1, RenderTheme::focusRingColor());
 }
 
-void CanvasRenderingContext2D::putImageData(ImageData& data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY,
-                                            float dirtyWidth, float dirtyHeight, ExceptionCode& ec)
+void CanvasRenderingContext2D::putImageData(ImageData& data, ImageBuffer::CoordinateSystem coordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight)
 {
-    if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dirtyX) || !std::isfinite(dirtyY) || !std::isfinite(dirtyWidth) || !std::isfinite(dirtyHeight)) {
-        ec = NOT_SUPPORTED_ERR;
-        return;
-    }
-
     ImageBuffer* buffer = canvas()->buffer();
     if (!buffer)
         return;
index ae4e0df..1e5cf75 100644 (file)
@@ -59,7 +59,7 @@ typedef int ExceptionCode;
 
 class CanvasRenderingContext2D final : public CanvasRenderingContext, public CanvasPath {
 public:
-    CanvasRenderingContext2D(HTMLCanvasElement*, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode);
+    CanvasRenderingContext2D(HTMLCanvasElement&, bool usesCSSCompatibilityParseMode, bool usesDashboardCompatibilityMode);
     virtual ~CanvasRenderingContext2D();
 
     const CanvasStyle& strokeStyle() const { return state().strokeStyle; }
@@ -158,45 +158,44 @@ public:
 
     void clearShadow();
 
-    void drawImage(HTMLImageElement&, float x, float y, ExceptionCode&);
-    void drawImage(HTMLImageElement&, float x, float y, float width, float height, ExceptionCode&);
-    void drawImage(HTMLImageElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
-    void drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
-    void drawImage(HTMLCanvasElement&, float x, float y, ExceptionCode&);
-    void drawImage(HTMLCanvasElement&, float x, float y, float width, float height, ExceptionCode&);
-    void drawImage(HTMLCanvasElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
-    void drawImage(HTMLCanvasElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
-    void drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator&, const BlendMode&, ExceptionCode&);
+    ExceptionOr<void> drawImage(HTMLImageElement&, float x, float y);
+    ExceptionOr<void> drawImage(HTMLImageElement&, float x, float y, float width, float height);
+    ExceptionOr<void> drawImage(HTMLImageElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh);
+    ExceptionOr<void> drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect);
+    ExceptionOr<void> drawImage(HTMLCanvasElement&, float x, float y);
+    ExceptionOr<void> drawImage(HTMLCanvasElement&, float x, float y, float width, float height);
+    ExceptionOr<void> drawImage(HTMLCanvasElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh);
+    ExceptionOr<void> drawImage(HTMLCanvasElement&, const FloatRect& srcRect, const FloatRect& dstRect);
+    ExceptionOr<void> drawImage(HTMLImageElement&, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator&, const BlendMode&);
 #if ENABLE(VIDEO)
-    void drawImage(HTMLVideoElement&, float x, float y, ExceptionCode&);
-    void drawImage(HTMLVideoElement&, float x, float y, float width, float height, ExceptionCode&);
-    void drawImage(HTMLVideoElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, ExceptionCode&);
-    void drawImage(HTMLVideoElement&, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode&);
+    ExceptionOr<void> drawImage(HTMLVideoElement&, float x, float y);
+    ExceptionOr<void> drawImage(HTMLVideoElement&, float x, float y, float width, float height);
+    ExceptionOr<void> drawImage(HTMLVideoElement&, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh);
+    ExceptionOr<void> drawImage(HTMLVideoElement&, const FloatRect& srcRect, const FloatRect& dstRect);
 #endif
 
-    void drawImageFromRect(HTMLImageElement&, float sx = 0, float sy = 0, float sw = 0, float sh = 0,
-                           float dx = 0, float dy = 0, float dw = 0, float dh = 0, const String& compositeOperation = emptyString());
+    void drawImageFromRect(HTMLImageElement&, float sx = 0, float sy = 0, float sw = 0, float sh = 0, float dx = 0, float dy = 0, float dw = 0, float dh = 0, const String& compositeOperation = emptyString());
 
     void setAlpha(float);
 
     void setCompositeOperation(const String&);
 
-    RefPtr<CanvasGradient> createLinearGradient(float x0, float y0, float x1, float y1, ExceptionCode&);
-    RefPtr<CanvasGradient> createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionCode&);
-    RefPtr<CanvasPattern> createPattern(HTMLImageElement&, const String& repetitionType, ExceptionCode&);
-    RefPtr<CanvasPattern> createPattern(HTMLCanvasElement&, const String& repetitionType, ExceptionCode&);
+    ExceptionOr<Ref<CanvasGradient>> createLinearGradient(float x0, float y0, float x1, float y1);
+    ExceptionOr<Ref<CanvasGradient>> createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1);
+    ExceptionOr<RefPtr<CanvasPattern>> createPattern(HTMLImageElement&, const String& repetitionType);
+    ExceptionOr<Ref<CanvasPattern>> createPattern(HTMLCanvasElement&, const String& repetitionType);
 #if ENABLE(VIDEO)
-    RefPtr<CanvasPattern> createPattern(HTMLVideoElement&, const String& repetitionType, ExceptionCode&);
+    ExceptionOr<RefPtr<CanvasPattern>> createPattern(HTMLVideoElement&, const String& repetitionType);
 #endif
 
-    RefPtr<ImageData> createImageData(RefPtr<ImageData>&&, ExceptionCode&) const;
-    RefPtr<ImageData> createImageData(float width, float height, ExceptionCode&) const;
-    RefPtr<ImageData> getImageData(float sx, float sy, float sw, float sh, ExceptionCode&) const;
-    RefPtr<ImageData> webkitGetImageDataHD(float sx, float sy, float sw, float sh, ExceptionCode&) const;
-    void putImageData(ImageData&, float dx, float dy, ExceptionCode&);
-    void putImageData(ImageData&, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
-    void webkitPutImageDataHD(ImageData&, float dx, float dy, ExceptionCode&);
-    void webkitPutImageDataHD(ImageData&, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
+    ExceptionOr<RefPtr<ImageData>> createImageData(ImageData*) const;
+    ExceptionOr<RefPtr<ImageData>> createImageData(float width, float height) const;
+    ExceptionOr<RefPtr<ImageData>> getImageData(float sx, float sy, float sw, float sh) const;
+    ExceptionOr<RefPtr<ImageData>> webkitGetImageDataHD(float sx, float sy, float sw, float sh) const;
+    void putImageData(ImageData&, float dx, float dy);
+    void putImageData(ImageData&, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
+    void webkitPutImageDataHD(ImageData&, float dx, float dy);
+    void webkitPutImageDataHD(ImageData&, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
 
     void drawFocusIfNeeded(Element*);
     void drawFocusIfNeeded(DOMPath&, Element*);
@@ -371,8 +370,8 @@ private:
 
     void prepareGradientForDashboard(CanvasGradient& gradient) const;
 
-    RefPtr<ImageData> getImageData(ImageBuffer::CoordinateSystem, float sx, float sy, float sw, float sh, ExceptionCode&) const;
-    void putImageData(ImageData&, ImageBuffer::CoordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight, ExceptionCode&);
+    ExceptionOr<RefPtr<ImageData>> getImageData(ImageBuffer::CoordinateSystem, float sx, float sy, float sw, float sh) const;
+    void putImageData(ImageData&, ImageBuffer::CoordinateSystem, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
 
     bool is2d() const override { return true; }
     bool isAccelerated() const override;
@@ -391,7 +390,6 @@ private:
 #if ENABLE(DASHBOARD_SUPPORT)
     bool m_usesDashboardCompatibilityMode;
 #endif
-
     bool m_usesDisplayListDrawing { false };
     bool m_tracksDisplayListReplay { false };
     mutable std::unique_ptr<struct DisplayListDrawingContext> m_recordingContext;
index 9259837..a993014 100644 (file)
@@ -53,8 +53,8 @@ enum CanvasWindingRule { "nonzero", "evenodd" };
 
     attribute DOMString globalCompositeOperation;
 
-    [MayThrowLegacyException] CanvasGradient createLinearGradient(float x0, float y0, float x1, float y1);
-    [MayThrowLegacyException] CanvasGradient createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1);
+    [MayThrowException] CanvasGradient createLinearGradient(float x0, float y0, float x1, float y1);
+    [MayThrowException] CanvasGradient createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1);
 
     attribute unrestricted float lineWidth;
     attribute DOMString lineCap;
@@ -132,21 +132,15 @@ enum CanvasWindingRule { "nonzero", "evenodd" };
 
     void strokeRect(unrestricted float x, unrestricted float y, unrestricted float width, unrestricted float height);
 
-    [MayThrowLegacyException] void drawImage(HTMLImageElement image, unrestricted float x, unrestricted float y);
-    [MayThrowLegacyException] void drawImage(HTMLImageElement image, unrestricted float x, unrestricted float y,
-        unrestricted float width, unrestricted float height);
-    [MayThrowLegacyException] void drawImage(HTMLImageElement image, unrestricted float sx, unrestricted float sy, unrestricted float sw,
-        unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
-    [MayThrowLegacyException] void drawImage(HTMLCanvasElement canvas, unrestricted float x, unrestricted float y);
-    [MayThrowLegacyException] void drawImage(HTMLCanvasElement canvas, unrestricted float x, unrestricted float y,
-        unrestricted float width, unrestricted float height);
-    [MayThrowLegacyException] void drawImage(HTMLCanvasElement canvas, unrestricted float sx, unrestricted float sy, unrestricted float sw,
-        unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
-    [Conditional=VIDEO, MayThrowLegacyException] void drawImage(HTMLVideoElement video, unrestricted float x, unrestricted float y);
-    [Conditional=VIDEO, MayThrowLegacyException] void drawImage(HTMLVideoElement video, unrestricted float x, unrestricted float y,
-        unrestricted float width, unrestricted float height);
-    [Conditional=VIDEO, MayThrowLegacyException] void drawImage(HTMLVideoElement video, unrestricted float sx, unrestricted float sy, unrestricted float sw,
-        unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
+    [MayThrowException] void drawImage(HTMLImageElement image, unrestricted float x, unrestricted float y);
+    [MayThrowException] void drawImage(HTMLImageElement image, unrestricted float x, unrestricted float y, unrestricted float width, unrestricted float height);
+    [MayThrowException] void drawImage(HTMLImageElement image, unrestricted float sx, unrestricted float sy, unrestricted float sw, unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
+    [MayThrowException] void drawImage(HTMLCanvasElement canvas, unrestricted float x, unrestricted float y);
+    [MayThrowException] void drawImage(HTMLCanvasElement canvas, unrestricted float x, unrestricted float y, unrestricted float width, unrestricted float height);
+    [MayThrowException] void drawImage(HTMLCanvasElement canvas, unrestricted float sx, unrestricted float sy, unrestricted float sw, unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
+    [Conditional=VIDEO, MayThrowException] void drawImage(HTMLVideoElement video, unrestricted float x, unrestricted float y);
+    [Conditional=VIDEO, MayThrowException] void drawImage(HTMLVideoElement video, unrestricted float x, unrestricted float y, unrestricted float width, unrestricted float height);
+    [Conditional=VIDEO, MayThrowException] void drawImage(HTMLVideoElement video, unrestricted float sx, unrestricted float sy, unrestricted float sw, unrestricted float sh, unrestricted float dx, unrestricted float dy, unrestricted float dw, unrestricted float dh);
 
     void drawImageFromRect(HTMLImageElement image,
         optional unrestricted float sx = 0, optional unrestricted float sy = 0, optional unrestricted float sw = 0, optional unrestricted float sh = 0,
@@ -162,25 +156,24 @@ enum CanvasWindingRule { "nonzero", "evenodd" };
     void setShadow(float width, unrestricted float height, unrestricted float blur, unrestricted float c, unrestricted float m, 
         unrestricted float y, unrestricted float k, unrestricted float a);
 
-    [MayThrowLegacyException] void putImageData(ImageData imagedata, float dx, float dy);
-    [MayThrowLegacyException] void putImageData(ImageData imagedata, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
+    void putImageData(ImageData imagedata, float dx, float dy);
+    void putImageData(ImageData imagedata, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
 
-    [MayThrowLegacyException] void webkitPutImageDataHD(ImageData imagedata, float dx, float dy);
-    [MayThrowLegacyException] void webkitPutImageDataHD(ImageData imagedata, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
+    void webkitPutImageDataHD(ImageData imagedata, float dx, float dy);
+    void webkitPutImageDataHD(ImageData imagedata, float dx, float dy, float dirtyX, float dirtyY, float dirtyWidth, float dirtyHeight);
 
-    [MayThrowLegacyException] CanvasPattern createPattern(HTMLCanvasElement canvas, [TreatNullAs=EmptyString] DOMString repetitionType);
-    [MayThrowLegacyException] CanvasPattern createPattern(HTMLImageElement image, [TreatNullAs=EmptyString] DOMString repetitionType);
-    [Conditional=VIDEO, MayThrowLegacyException] CanvasPattern? createPattern(HTMLVideoElement video, [TreatNullAs=EmptyString] DOMString repetitionType);
-    [MayThrowLegacyException] ImageData createImageData(ImageData? imagedata);
-    [MayThrowLegacyException] ImageData createImageData(float sw, float sh);
+    [MayThrowException] CanvasPattern createPattern(HTMLCanvasElement canvas, [TreatNullAs=EmptyString] DOMString repetitionType);
+    [MayThrowException] CanvasPattern createPattern(HTMLImageElement image, [TreatNullAs=EmptyString] DOMString repetitionType);
+    [Conditional=VIDEO, MayThrowException] CanvasPattern? createPattern(HTMLVideoElement video, [TreatNullAs=EmptyString] DOMString repetitionType);
+    [MayThrowException] ImageData createImageData(ImageData? imagedata);
+    [MayThrowException] ImageData createImageData(float sw, float sh);
 
     [Custom] attribute custom strokeStyle;
     [Custom] attribute custom fillStyle;
 
     // pixel manipulation
-    [MayThrowLegacyException] ImageData getImageData(float sx, float sy, float sw, float sh);
-
-    [MayThrowLegacyException] ImageData webkitGetImageDataHD(float sx, float sy, float sw, float sh);
+    [MayThrowException] ImageData getImageData(float sx, float sy, float sw, float sh);
+    [MayThrowException] ImageData webkitGetImageDataHD(float sx, float sy, float sw, float sh);
     
     // Focus rings
     void drawFocusIfNeeded(Element? element); // FIXME: The element parameter should not be nullable.
index 8ee7b63..30ffd2d 100644 (file)
  */
 
 #include "config.h"
+#include "OESVertexArrayObject.h"
 
 #if ENABLE(WEBGL)
 
-#include "OESVertexArrayObject.h"
-
 #include "Extensions3D.h"
 #include "WebGLRenderingContext.h"
 
 namespace WebCore {
 
-OESVertexArrayObject::OESVertexArrayObject(WebGLRenderingContextBase* context)
-    : WebGLExtension(context)
-{
-}
-
-OESVertexArrayObject::~OESVertexArrayObject()
+OESVertexArrayObject::OESVertexArrayObject(WebGLRenderingContextBase& context)
+    : WebGLExtension(&context)
 {
 }
 
@@ -52,7 +47,7 @@ RefPtr<WebGLVertexArrayObjectOES> OESVertexArrayObject::createVertexArrayOES()
 {
     if (m_context->isContextLost())
         return nullptr;
-    
+
     auto object = WebGLVertexArrayObjectOES::create(m_context, WebGLVertexArrayObjectOES::VAOTypeUser);
     m_context->addContextObject(object.ptr());
     return WTFMove(object);
@@ -71,36 +66,29 @@ void OESVertexArrayObject::deleteVertexArrayOES(WebGLVertexArrayObjectOES* array
 
 GC3Dboolean OESVertexArrayObject::isVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
 {
-    if (!arrayObject || m_context->isContextLost())
-        return 0;
-    
-    if (!arrayObject->hasEverBeenBound())
-        return 0;
-    
-    Extensions3D* extensions = m_context->graphicsContext3D()->getExtensions();
-    return extensions->isVertexArrayOES(arrayObject->object());
+    return arrayObject && !m_context->isContextLost() && arrayObject->hasEverBeenBound()
+        && m_context->graphicsContext3D()->getExtensions()->isVertexArrayOES(arrayObject->object());
 }
 
-void OESVertexArrayObject::bindVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject, ExceptionCode& ec)
+void OESVertexArrayObject::bindVertexArrayOES(WebGLVertexArrayObjectOES* arrayObject)
 {
-    UNUSED_PARAM(ec);
     if (m_context->isContextLost())
         return;
-    
+
     if (arrayObject && (arrayObject->isDeleted() || !arrayObject->validate(0, context()))) {
         m_context->graphicsContext3D()->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
         return;
     }
-    
-    Extensions3D* extensions = m_context->graphicsContext3D()->getExtensions();
+
+    auto& extensions = *m_context->graphicsContext3D()->getExtensions();
+    auto& context = downcast<WebGLRenderingContext>(*m_context);
     if (arrayObject && !arrayObject->isDefaultObject() && arrayObject->object()) {
-        extensions->bindVertexArrayOES(arrayObject->object());
-        
+        extensions.bindVertexArrayOES(arrayObject->object());
         arrayObject->setHasEverBeenBound();
-        static_cast<WebGLRenderingContext*>(m_context)->setBoundVertexArrayObject(arrayObject);
+        context.setBoundVertexArrayObject(arrayObject);
     } else {
-        extensions->bindVertexArrayOES(0);
-        static_cast<WebGLRenderingContext*>(m_context)->setBoundVertexArrayObject(0);
+        extensions.bindVertexArrayOES(0);
+        context.setBoundVertexArrayObject(0);
     }
 }
 
index 59e93e1..0654954 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef OESVertexArrayObject_h
-#define OESVertexArrayObject_h
+#pragma once
 
 #include "GraphicsTypes3D.h"
 #include "WebGLExtension.h"
@@ -34,21 +33,17 @@ namespace WebCore {
 class WebGLRenderingContextBase;
 class WebGLVertexArrayObjectOES;
 
-typedef int ExceptionCode;
-
 class OESVertexArrayObject final : public WebGLExtension {
 public:
-    OESVertexArrayObject(WebGLRenderingContextBase*);
-    virtual ~OESVertexArrayObject();
+    explicit OESVertexArrayObject(WebGLRenderingContextBase&);
 
-    ExtensionName getName() const override;
-    
     RefPtr<WebGLVertexArrayObjectOES> createVertexArrayOES();
     void deleteVertexArrayOES(WebGLVertexArrayObjectOES*);
     GC3Dboolean isVertexArrayOES(WebGLVertexArrayObjectOES*);
-    void bindVertexArrayOES(WebGLVertexArrayObjectOES*, ExceptionCode&);
+    void bindVertexArrayOES(WebGLVertexArrayObjectOES*);
+
+private:
+    ExtensionName getName() const final;
 };
 
 } // namespace WebCore
-
-#endif // OESVertexArrayObject_h
index c7bf338..62bdd04 100644 (file)
@@ -34,5 +34,5 @@
     WebGLVertexArrayObjectOES createVertexArrayOES();
     void deleteVertexArrayOES(optional WebGLVertexArrayObjectOES? arrayObject = null);
     boolean isVertexArrayOES(optional WebGLVertexArrayObjectOES? arrayObject = null);
-    [MayThrowLegacyException] void bindVertexArrayOES(optional WebGLVertexArrayObjectOES? arrayObject = null);
+    void bindVertexArrayOES(optional WebGLVertexArrayObjectOES? arrayObject = null);
 };
index 727ef33..dd0198f 100644 (file)
@@ -64,8 +64,8 @@ WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas,
 {
 }
 
-WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, RefPtr<GraphicsContext3D>&& context,
-    GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, WTFMove(context), attributes)
+WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, RefPtr<GraphicsContext3D>&& context, GraphicsContext3D::Attributes attributes)
+    : WebGLRenderingContextBase(passedCanvas, WTFMove(context), attributes)
 {
     initializeShaderExtensions();
     initializeVertexArrayObjects();
@@ -807,7 +807,7 @@ Vector<String> WebGL2RenderingContext::getSupportedExtensions()
     return result;
 }
 
-WebGLGetInfo WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&)
+WebGLGetInfo WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
 {
     if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return WebGLGetInfo();
@@ -1039,9 +1039,8 @@ void WebGL2RenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3D
     tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
 }
 
-void WebGL2RenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)
+void WebGL2RenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels)
 {
-    ec = 0;
     ASSERT(!isContextLost());
     if (!validateTexFuncParameters("texSubImage2D", TexSubImage, target, level, internalformat, width, height, 0, format, type))
         return;
@@ -1061,9 +1060,8 @@ void WebGL2RenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, G
     m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
-void WebGL2RenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)
+void WebGL2RenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha)
 {
-    ec = 0;
     Vector<uint8_t> data;
     GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);
     if (!imageExtractor.extractSucceeded()) {
@@ -1089,12 +1087,12 @@ void WebGL2RenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, G
     
     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
     GC3Denum internalformat = tex->getInternalFormat(target, level);
-    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), internalformat, format, type,  needConversion ? data.data() : imagePixelData, ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), internalformat, format, type,  needConversion ? data.data() : imagePixelData);
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels, ExceptionCode& ec)
+void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels)
 {
     if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, GraphicsContext3D::NONE, format, type, pixels.get(), NullNotAllowed) || !validateTexFunc("texSubImage2D", TexSubImage, SourceArrayBufferView, target, level, GraphicsContext3D::NONE, width, height, 0, format, type, xoffset, yoffset))
         return;
@@ -1116,14 +1114,13 @@ void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Di
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
     GC3Denum internalformat = tex->getInternalFormat(target, level);
-    texSubImage2DBase(target, level, xoffset, yoffset, width, height, internalformat, format, type, data, ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, width, height, internalformat, format, type, data);
     if (changeUnpackAlignment)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)
+void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData* pixels)
 {
-    ec = 0;
     if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage, SourceImageData, target, level, GraphicsContext3D::NONE,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))
         return;
     
@@ -1144,58 +1141,65 @@ void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Di
     
     WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);
     GC3Denum internalformat = tex->getInternalFormat(target, level);
-    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), internalformat, format, type, needConversion ? data.data() : pixels->data()->data(), ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), internalformat, format, type, needConversion ? data.data() : pixels->data()->data());
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)
+ExceptionOr<void> WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement* image)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))
-        return;
-    
+    if (wouldTaintOrigin(image))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image))
+        return { };
+
     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
     if (!imageForRender)
-        return;
+        return { };
 
     if (imageForRender->isSVGImage())
         imageForRender = drawImageIntoBuffer(*imageForRender, image->width(), image->height(), 1);
     
     if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLImageElement, target, level, GraphicsContext3D::NONE, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))
-        return;
+        return { };
     
-    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
 
-void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-    GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)
+ExceptionOr<void> WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)
+    if (wouldTaintOrigin(canvas))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas)
         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLCanvasElement, target, level, GraphicsContext3D::NONE, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))
-        return;
-    
+        return { };
+
     RefPtr<ImageData> imageData = canvas->getImageData();
     if (imageData)
-        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);
+        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get());
     else
-        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
 
 #if ENABLE(VIDEO)
-void WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)
+
+ExceptionOr<void> WebGL2RenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* video)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)
+    if (wouldTaintOrigin(video))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video)
         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLVideoElement, target, level, GraphicsContext3D::NONE, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))
-        return;
-    
+        return { };
+
     RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode());
     if (!image)
-        return;
-    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+        return { };
+    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
+
 #endif
 
 bool WebGL2RenderingContext::validateTexFuncParameters(const char* functionName, TexFuncValidationFunctionType functionType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type)
@@ -1243,8 +1247,7 @@ bool WebGL2RenderingContext::validateTexFuncParameters(const char* functionName,
             return false;
         }
 
-        ExceptionCode ec;
-        bool isSRGB = (getFramebufferAttachmentParameter(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, ec).getInt() == GraphicsContext3D::SRGB);
+        bool isSRGB = (getFramebufferAttachmentParameter(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING).getInt() == GraphicsContext3D::SRGB);
         if (isSRGB != (framebufferInternalFormat == GraphicsContext3D::SRGB8 || framebufferInternalFormat == GraphicsContext3D::SRGB8_ALPHA8)) {
             synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "framebuffer attachment color encoding and internal format do not match");
         return false;
@@ -1813,7 +1816,7 @@ bool WebGL2RenderingContext::isIntegerFormat(GC3Denum internalformat)
     return false;
 }
 
-WebGLGetInfo WebGL2RenderingContext::getParameter(GC3Denum pname, ExceptionCode&)
+WebGLGetInfo WebGL2RenderingContext::getParameter(GC3Denum pname)
 {
     if (isContextLostOrPending())
         return WebGLGetInfo();
index 5dde45a..8ef8efa 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebGL2RenderingContext_h
-#define WebGL2RenderingContext_h
+#pragma once
 
 #if ENABLE(WEBGL2)
 
@@ -43,7 +42,6 @@ class WebGL2RenderingContext final : public WebGLRenderingContextBase {
 public:
     WebGL2RenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);
     WebGL2RenderingContext(HTMLCanvasElement*, RefPtr<GraphicsContext3D>&&, GraphicsContext3D::Attributes);
-    bool isWebGL2() const override { return true; }
 
     /* Buffer objects */
     void bufferData(GC3Denum target, ArrayBufferView& data, GC3Denum usage, GC3Duint srcOffset, GC3Duint length);
@@ -53,7 +51,7 @@ public:
     void getBufferSubData(GC3Denum target, GC3Dint64 offset, ArrayBuffer* returnedData);
     
     /* Framebuffer objects */
-    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&) override;
+    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) final;
     void blitFramebuffer(GC3Dint srcX0, GC3Dint srcY0, GC3Dint srcX1, GC3Dint srcY1, GC3Dint dstX0, GC3Dint dstY0, GC3Dint dstX1, GC3Dint dstY1, GC3Dbitfield mask, GC3Denum filter);
     void framebufferTextureLayer(GC3Denum target, GC3Denum attachment, GC3Duint texture, GC3Dint level, GC3Dint layer);
     WebGLGetInfo getInternalformatParameter(GC3Denum target, GC3Denum internalformat, GC3Denum pname);
@@ -102,7 +100,7 @@ public:
     void vertexAttribIPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dsizei stride, GC3Dint64 offset);
     
     /* Writing to the drawing buffer */
-    void clear(GC3Dbitfield mask) override;
+    void clear(GC3Dbitfield mask) final;
     void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
     void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount);
     void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount);
@@ -170,52 +168,47 @@ public:
     GC3Dboolean isVertexArray(WebGLVertexArrayObject* vertexArray);
     void bindVertexArray(WebGLVertexArrayObject* vertexArray);
     
+private:
+    bool isWebGL2() const final { return true; }
+
     /* Extensions */
-    WebGLExtension* getExtension(const String&) override;
-    Vector<String> getSupportedExtensions() override;
-    WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&) override;
+    WebGLExtension* getExtension(const String&) final;
+    Vector<String> getSupportedExtensions() final;
+    WebGLGetInfo getParameter(GC3Denum pname) final;
 
-    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) override;
-    void hint(GC3Denum target, GC3Denum mode) override;
-    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) override;
-    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&) override;
-    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Dsizei width, GC3Dsizei height,
-        GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&) override;
+    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
+    void hint(GC3Denum target, GC3Denum mode) final;
+    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) final;
+    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels) final;
+    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha) final;
+    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&) final;
+    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData*) final;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement*) final;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement*) final;
 #if ENABLE(VIDEO)
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&) override;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement*) final;
 #endif
 
-protected:
-    void initializeVertexArrayObjects() override;
-    GC3Dint getMaxDrawBuffers() override;
-    GC3Dint getMaxColorAttachments() override;
-    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) override;
-    bool validateBlendEquation(const char* functionName, GC3Denum mode) override;
-    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level) override;
+    void initializeVertexArrayObjects() final;
+    GC3Dint getMaxDrawBuffers() final;
+    GC3Dint getMaxColorAttachments() final;
+    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) final;
+    bool validateBlendEquation(const char* functionName, GC3Denum mode) final;
+    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level) final;
     bool validateTexFuncParameters(const char* functionName,
         TexFuncValidationFunctionType,
         GC3Denum target, GC3Dint level,
         GC3Denum internalformat,
         GC3Dsizei width, GC3Dsizei height, GC3Dint border,
-        GC3Denum format, GC3Denum type) override;
+        GC3Denum format, GC3Denum type) final;
     bool validateTexFuncData(const char* functionName, GC3Dint level,
         GC3Dsizei width, GC3Dsizei height,
         GC3Denum internalformat, GC3Denum format, GC3Denum type,
         ArrayBufferView* pixels,
-        NullDisposition) override;
-    bool validateCapability(const char* functionName, GC3Denum cap) override;
-    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) override;
+        NullDisposition) final;
+    bool validateCapability(const char* functionName, GC3Denum cap) final;
+    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) final;
     
-private:
     GC3Denum baseInternalFormatFromInternalFormat(GC3Denum internalformat);
     bool isIntegerFormat(GC3Denum internalformat);
     void initializeShaderExtensions();
@@ -226,5 +219,3 @@ private:
 SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::WebGL2RenderingContext, isWebGL2())
 
 #endif // WEBGL2
-
-#endif
index 44aadc7..0f0920b 100644 (file)
@@ -173,7 +173,7 @@ WebGLExtension* WebGLRenderingContext::getExtension(const String& name)
         && m_context->getExtensions()->supports("GL_OES_vertex_array_object")) {
         if (!m_oesVertexArrayObject) {
             m_context->getExtensions()->ensureEnabled("GL_OES_vertex_array_object");
-            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(this);
+            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(*this);
         }
         return m_oesVertexArrayObject.get();
     }
@@ -296,9 +296,8 @@ Vector<String> WebGLRenderingContext::getSupportedExtensions()
     return result;
 }
 
-WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)
+WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
 {
-    UNUSED_PARAM(ec);
     if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return WebGLGetInfo();
     
@@ -510,11 +509,9 @@ void WebGLRenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3De
     tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
 }
 
-void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)
+void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels)
 {
     UNUSED_PARAM(internalformat);
-    // FIXME: For now we ignore any errors returned
-    ec = 0;
     ASSERT(!isContextLost());
     ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage, target, level, format, width, height, 0, format, type));
     ASSERT(validateSize("texSubImage2D", xoffset, yoffset));
@@ -533,9 +530,8 @@ void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC
     m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
-void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)
+void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha)
 {
-    ec = 0;
     Vector<uint8_t> data;
     GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);
     if (!imageExtractor.extractSucceeded()) {
@@ -559,12 +555,12 @@ void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
 
-    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, format, type, needConversion ? data.data() : imagePixelData, ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, format, type, needConversion ? data.data() : imagePixelData);
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels, ExceptionCode& ec)
+void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels)
 {
     if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, format, format, type, pixels.get(), NullNotAllowed) || !validateTexFunc("texSubImage2D", TexSubImage, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))
         return;
@@ -585,14 +581,13 @@ void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Din
     if (changeUnpackAlignment)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
 
-    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, format, type, data, ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, format, type, data);
     if (changeUnpackAlignment)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)
+void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData* pixels)
 {
-    ec = 0;
     if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))
         return;
     
@@ -611,57 +606,65 @@ void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Din
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
     
-    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, format, type, needConversion ? data.data() : pixels->data()->data(), ec);
+    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, format, type, needConversion ? data.data() : pixels->data()->data());
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)
+ExceptionOr<void> WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement* image)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))
-        return;
-    
+    if (wouldTaintOrigin(image))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image))
+        return { };
+
     RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
     if (!imageForRender)
-        return;
+        return { };
 
     if (imageForRender->isSVGImage())
         imageForRender = drawImageIntoBuffer(*imageForRender, image->width(), image->height(), 1);
     
     if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLImageElement, target, level, format, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))
-        return;
-    
-    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+        return { };
+
+    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
 
-void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)
+ExceptionOr<void> WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)
+    if (wouldTaintOrigin(canvas))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas)
         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLCanvasElement, target, level, format, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))
-        return;
-    
+        return { };
+
     RefPtr<ImageData> imageData = canvas->getImageData();
     if (imageData)
-        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);
+        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get());
     else
-        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
 
 #if ENABLE(VIDEO)
-void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)
+
+ExceptionOr<void> WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement* video)
 {
-    ec = 0;
-    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)
+    if (wouldTaintOrigin(video))
+        return Exception { SECURITY_ERR };
+    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video)
         || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLVideoElement, target, level, format, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))
-        return;
-    
+        return { };
+
     RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode());
     if (!image)
-        return;
-    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+        return { };
+    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return { };
 }
+
 #endif
 
 bool WebGLRenderingContext::validateTexFuncParameters(const char* functionName,
@@ -915,9 +918,8 @@ bool WebGLRenderingContext::validateTexFuncData(const char* functionName, GC3Din
     return true;
 }
 
-WebGLGetInfo WebGLRenderingContext::getParameter(GC3Denum pname, ExceptionCode& ec)
+WebGLGetInfo WebGLRenderingContext::getParameter(GC3Denum pname)
 {
-    UNUSED_PARAM(ec);
     if (isContextLostOrPending())
         return WebGLGetInfo();
     const int intZero = 0;
index 2037929..84517a5 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef WebGLRenderingContext_h
-#define WebGLRenderingContext_h
+#pragma once
 
 #include "WebGLRenderingContextBase.h"
 
@@ -34,57 +33,41 @@ class WebGLRenderingContext final : public WebGLRenderingContextBase {
 public:
     WebGLRenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);
     WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
-    bool isWebGL1() const override { return true; }
-    
-    WebGLExtension* getExtension(const String&) override;
-    WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&) override;
-    Vector<String> getSupportedExtensions() override;
 
-    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&) override;
-    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) override;
-    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) override;
-    void hint(GC3Denum target, GC3Denum mode) override;
-    void clear(GC3Dbitfield mask) override;
-    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) override;
-    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&) override;
-    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Dsizei width, GC3Dsizei height,
-        GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&) override;
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&) override;
+private:
+    bool isWebGL1() const final { return true; }
+
+    WebGLExtension* getExtension(const String&) final;
+    WebGLGetInfo getParameter(GC3Denum pname) final;
+    Vector<String> getSupportedExtensions() final;
+
+    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) final;
+    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) final;
+    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) final;
+    void hint(GC3Denum target, GC3Denum mode) final;
+    void clear(GC3Dbitfield mask) final;
+    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border) final;
+    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels) final;
+    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha) final;
+    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&) final;
+    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData*) final;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement*) final;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement*) final;
 #if ENABLE(VIDEO)
-    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&) override;
+    ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement*) final;
 #endif
 
-protected:
-    GC3Dint getMaxDrawBuffers() override;
-    GC3Dint getMaxColorAttachments() override;
-    void initializeVertexArrayObjects() override;
-    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) override;
-    bool validateBlendEquation(const char* functionName, GC3Denum mode) override;
-    bool validateTexFuncParameters(const char* functionName,
-        TexFuncValidationFunctionType,
-        GC3Denum target, GC3Dint level,
-        GC3Denum internalformat,
-        GC3Dsizei width, GC3Dsizei height, GC3Dint border,
-        GC3Denum format, GC3Denum type) override;
-    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level) override;
-    bool validateTexFuncData(const char* functionName, GC3Dint level,
-        GC3Dsizei width, GC3Dsizei height,
-        GC3Denum internalformat, GC3Denum format, GC3Denum type,
-        ArrayBufferView* pixels,
-        NullDisposition) override;
-    bool validateCapability(const char* functionName, GC3Denum cap) override;
+    GC3Dint getMaxDrawBuffers() final;
+    GC3Dint getMaxColorAttachments() final;
+    void initializeVertexArrayObjects() final;
+    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) final;
+    bool validateBlendEquation(const char* functionName, GC3Denum mode) final;
+    bool validateTexFuncParameters(const char* functionName, TexFuncValidationFunctionType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type) final;
+    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level) final;
+    bool validateTexFuncData(const char* functionName, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, NullDisposition) final;
+    bool validateCapability(const char* functionName, GC3Denum cap) final;
 };
     
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::WebGLRenderingContext, isWebGL1())
-
-#endif
index 1d3eac9..03537b5 100644 (file)
@@ -2976,10 +2976,9 @@ void WebGLRenderingContextBase::stencilOpSeparate(GC3Denum face, GC3Denum fail,
     m_context->stencilOpSeparate(face, fail, zfail, zpass);
 }
 
-void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)
+void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
 {
     // FIXME: For now we ignore any errors returned.
-    ec = 0;
     WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);
     ASSERT(validateTexFuncParameters("texImage2D", TexImage, target, level, internalformat, width, height, border, format, type));
     ASSERT(tex);
@@ -3011,9 +3010,8 @@ void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, G
     tex->setLevelInfo(target, level, internalformat, width, height, type);
 }
 
-void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)
+void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha)
 {
-    ec = 0;
     Vector<uint8_t> data;
     GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);
     if (!imageExtractor.extractSucceeded()) {
@@ -3036,7 +3034,7 @@ void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, G
 
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
-    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);
+    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData);
     if (m_unpackAlignment != 1)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
@@ -3082,7 +3080,7 @@ bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFun
     return true;
 }
 
-void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels, ExceptionCode& ec)
+void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&& pixels)
 {
     if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, internalformat, format, type, pixels.get(), NullAllowed)
         || !validateTexFunc("texImage2D", TexImage, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))
@@ -3102,23 +3100,21 @@ void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3De
     }
     if (changeUnpackAlignment)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
-    texImage2DBase(target, level, internalformat, width, height, border,
-                   format, type, data, ec);
+    texImage2DBase(target, level, internalformat, width, height, border, format, type, data);
     if (changeUnpackAlignment)
         m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
-void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource> source, ExceptionCode& ec)
+ExceptionOr<void> WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource> source)
 {
     if (!source) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "source is null");
-        return;
+        return { };
     }
 
-    auto visitor = WTF::makeVisitor([&](const RefPtr<ImageData>& pixels) {
-        ec = 0;
+    auto visitor = WTF::makeVisitor([&](const RefPtr<ImageData>& pixels) -> ExceptionOr<void> {
         if (isContextLostOrPending() || !validateTexFunc("texImage2D", TexImage, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))
-            return;
+            return { };
         Vector<uint8_t> data;
         bool needConversion = true;
         // The data from ImageData is always of format RGBA8.
@@ -3128,35 +3124,38 @@ void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3De
         else {
             if (!m_context->extractImageData(pixels.get(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
                 synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");
-                return;
+                return { };
             }
         }
         if (m_unpackAlignment != 1)
             m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);
-        texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);
+        texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data());
         if (m_unpackAlignment != 1)
             m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);
-    }, [&](const RefPtr<HTMLImageElement>& image) {
-        ec = 0;
-        if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image.get(), ec))
-            return;
+        return { };
+    }, [&](const RefPtr<HTMLImageElement>& image) -> ExceptionOr<void> {
+        if (wouldTaintOrigin(image.get()))
+            return Exception { SECURITY_ERR };
+        if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image.get()))
+            return { };
 
         RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());
         if (!imageForRender)
-            return;
+            return { };
 
         if (imageForRender->isSVGImage())
             imageForRender = drawImageIntoBuffer(*imageForRender, image->width(), image->height(), 1);
 
         if (!imageForRender || !validateTexFunc("texImage2D", TexImage, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))
-            return;
-
-        texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+            return { };
 
-    }, [&](const RefPtr<HTMLCanvasElement>& canvas) {
-        ec = 0;
-        if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas.get(), ec) || !validateTexFunc("texImage2D", TexImage, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))
-            return;
+        texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+        return { };
+    }, [&](const RefPtr<HTMLCanvasElement>& canvas) -> ExceptionOr<void> {
+        if (wouldTaintOrigin(canvas.get()))
+            return Exception { SECURITY_ERR };
+        if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas.get()) || !validateTexFunc("texImage2D", TexImage, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))
+            return { };
 
         WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);
         // If possible, copy from the canvas element directly to the texture
@@ -3171,20 +3170,22 @@ void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3De
             ImageBuffer* buffer = canvas->buffer();
             if (buffer && buffer->copyToPlatformTexture(*m_context.get(), target, texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                 texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);
-                return;
+                return { };
             }
         }
 
         RefPtr<ImageData> imageData = canvas->getImageData();
         if (imageData)
-            texImage2D(target, level, internalformat, format, type, TexImageSource(imageData.get()), ec);
+            texImage2D(target, level, internalformat, format, type, TexImageSource(imageData.get()));
         else
-            texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
-    }, [&](const RefPtr<HTMLVideoElement>& video) {
-        ec = 0;
-        if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video.get(), ec)
+            texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
+        return { };
+    }, [&](const RefPtr<HTMLVideoElement>& video) -> ExceptionOr<void> {
+        if (wouldTaintOrigin(video.get()))
+            return Exception { SECURITY_ERR };
+        if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video.get())
             || !validateTexFunc("texImage2D", TexImage, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))
-            return;
+            return { };
 
         // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.
         // Otherwise, it will fall back to the normal SW path.
@@ -3198,18 +3199,19 @@ void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3De
             && !level) {
             if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), target, level, internalformat, format, type, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                 texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);
-                return;
+                return { };
             }
         }
 
         // Normal pure SW path.
         RefPtr<Image> image = videoFrameToImage(video.get(), ImageBuffer::fastCopyImageMode());
         if (!image)
-            return;
-        texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);
+            return { };
+        texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
+        return { };
     });
 
-    WTF::visit(visitor, source.value());
+    return WTF::visit(visitor, source.value());
 }
 
 RefPtr<Image> WebGLRenderingContextBase::drawImageIntoBuffer(Image& image, int width, int height, int deviceScaleFactor)
@@ -4472,7 +4474,7 @@ WebGLBuffer* WebGLRenderingContextBase::validateBufferDataParameters(const char*
     return nullptr;
 }
 
-bool WebGLRenderingContextBase::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionCode& ec)
+bool WebGLRenderingContextBase::validateHTMLImageElement(const char* functionName, HTMLImageElement* image)
 {
     if (!image || !image->cachedImage()) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");
@@ -4483,39 +4485,29 @@ bool WebGLRenderingContextBase::validateHTMLImageElement(const char* functionNam
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");
         return false;
     }
-    if (wouldTaintOrigin(image)) {
-        ec = SECURITY_ERR;
-        return false;
-    }
     return true;
 }
 
-bool WebGLRenderingContextBase::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas, ExceptionCode& ec)
+bool WebGLRenderingContextBase::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas)
 {
     if (!canvas || !canvas->buffer()) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no canvas");
         return false;
     }
-    if (wouldTaintOrigin(canvas)) {
-        ec = SECURITY_ERR;
-        return false;
-    }
     return true;
 }
 
 #if ENABLE(VIDEO)
-bool WebGLRenderingContextBase::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video, ExceptionCode& ec)
+
+bool WebGLRenderingContextBase::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video)
 {
     if (!video || !video->videoWidth() || !video->videoHeight()) {
         synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no video");
         return false;
     }
-    if (wouldTaintOrigin(video)) {
-        ec = SECURITY_ERR;
-        return false;
-    }
     return true;
 }
+
 #endif
 
 void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
index 7cd3944..99aaf90 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef WebGLRenderingContextBase_h
-#define WebGLRenderingContextBase_h
+#pragma once
 
 #include "ActiveDOMObject.h"
 #include "CanvasRenderingContext.h"
@@ -37,8 +36,6 @@
 #include <memory>
 #include <runtime/Float32Array.h>
 #include <runtime/Int32Array.h>
-#include <wtf/Variant.h>
-#include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
@@ -84,8 +81,6 @@ class WebGLShaderPrecisionFormat;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
 
-typedef int ExceptionCode;
-
 inline void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)
 {
     ASSERT(clippedStart && clippedRange);
@@ -200,8 +195,8 @@ public:
     RefPtr<WebGLContextAttributes> getContextAttributes();
     GC3Denum getError();
     virtual WebGLExtension* getExtension(const String& name) = 0;
-    virtual WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&) = 0;
-    virtual WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&) = 0;
+    virtual WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) = 0;
+    virtual WebGLGetInfo getParameter(GC3Denum pname) = 0;
     WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname);
     String getProgramInfoLog(WebGLProgram*);
     WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname);
@@ -243,26 +238,20 @@ public:
     void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
     void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
 
-    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&, ExceptionCode&);
+    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&);
 
     using TexImageSource = WTF::Variant<RefPtr<ImageData>, RefPtr<HTMLImageElement>, RefPtr<HTMLCanvasElement>, RefPtr<HTMLVideoElement>>;
-    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource>, ExceptionCode&);
+    ExceptionOr<void> texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Optional<TexImageSource>);
 
     void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
     void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
 
-    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Dsizei width, GC3Dsizei height,
-        GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&, ExceptionCode&) = 0;
-    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&) = 0;
-    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&) = 0;
-    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&) = 0;
+    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&) = 0;
+    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, ImageData*) = 0;
+    virtual ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLImageElement*) = 0;
+    virtual ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLCanvasElement*) = 0;
 #if ENABLE(VIDEO)
-    virtual void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-        GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&) = 0;
+    virtual ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, HTMLVideoElement*) = 0;
 #endif
 
     void uniform1f(const WebGLUniformLocation*, GC3Dfloat x);
@@ -602,10 +591,10 @@ protected:
     // Helper to restore state that clearing the framebuffer may destroy.
     void restoreStateAfterClear();
 
-    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
-    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
-    virtual void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&) = 0;
-    virtual void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&) = 0;
+    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels);
+    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha);
+    virtual void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels) = 0;
+    virtual void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha) = 0;
 
     bool checkTextureCompleteness(const char*, bool);
 
@@ -758,15 +747,11 @@ protected:
     // Return the current bound buffer to target, or 0 if parameters are invalid.
     WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
 
-    // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.
-    bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);
-
-    // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.
-    bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);
-
+    // Helper function for tex{Sub}Image2D to make sure image is ready.
+    bool validateHTMLImageElement(const char* functionName, HTMLImageElement*);
+    bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*);
 #if ENABLE(VIDEO)
-    // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.
-    bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);
+    bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*);
 #endif
 
     // Helper functions for vertexAttribNf{v}.
@@ -793,19 +778,13 @@ protected:
     // Helper for restoration after context lost.
     void maybeRestoreContext();
 
-    enum ConsoleDisplayPreference {
-        DisplayInConsole,
-        DontDisplayInConsole
-    };
-
-    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message
-    // to the JavaScript console.
+    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message to the JavaScript console.
+    enum ConsoleDisplayPreference { DisplayInConsole, DontDisplayInConsole };
     void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
 
     String ensureNotNull(const String&) const;
 
-    // Enable or disable stencil test based on user setting and
-    // whether the current FBO has a stencil buffer.
+    // Enable or disable stencil test based on user setting and whether the current FBO has a stencil buffer.
     void applyStencilTest();
 
     // Helper for enabling or disabling a capability.
@@ -829,5 +808,3 @@ protected:
 } // namespace WebCore
 
 SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::WebGLRenderingContextBase, is3d())
-
-#endif
index 91f96db..5cf6b7e 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-typedef unsigned long  GLenum;
+typedef unsigned long GLenum;
 typedef boolean GLboolean;
-typedef unsigned long  GLbitfield;
-typedef byte   GLbyte; /* 'byte' should be a signed 8 bit type. */
-typedef short  GLshort;
-typedef long   GLint;
-typedef long   GLsizei;
-typedef long long  GLintptr;
-typedef long long  GLsizeiptr;
-typedef octet  GLubyte; /* 'octet' should be an unsigned 8 bit type. */
+typedef unsigned long GLbitfield;
+typedef byte GLbyte; /* 'byte' should be a signed 8 bit type. */
+typedef short GLshort;
+typedef long GLint;
+typedef long GLsizei;
+typedef long long GLintptr;
+typedef long long GLsizeiptr;
+typedef octet GLubyte; /* 'octet' should be an unsigned 8 bit type. */
 typedef unsigned short GLushort;
-typedef unsigned long  GLuint;
+typedef unsigned long GLuint;
 typedef unrestricted float GLfloat;
 typedef unrestricted float GLclampf;
 typedef (ArrayBuffer or ArrayBufferView) BufferDataSource;
@@ -545,7 +545,7 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     WebGLActiveInfo getActiveAttrib(WebGLProgram? program, GLuint index);
     WebGLActiveInfo getActiveUniform(WebGLProgram? program, GLuint index);
 
-    [Custom, MayThrowLegacyException] void getAttachedShaders(WebGLProgram? program);
+    [Custom] void getAttachedShaders(WebGLProgram? program);
 
     GLint getAttribLocation(WebGLProgram? program, DOMString name);
 
@@ -558,12 +558,12 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     // object getExtension(DOMString name);
     [Custom] any getExtension(DOMString name);
 
-    [Custom, MayThrowLegacyException] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
-    [Custom, MayThrowLegacyException] any getParameter(GLenum pname);
-    [Custom, MayThrowLegacyException] any getProgramParameter(WebGLProgram? program, GLenum pname);
+    [Custom] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
+    [Custom] any getParameter(GLenum pname);
+    [Custom] any getProgramParameter(WebGLProgram? program, GLenum pname);
     DOMString? getProgramInfoLog(WebGLProgram? program);
-    [Custom, MayThrowLegacyException] any getRenderbufferParameter(GLenum target, GLenum pname);
-    [Custom, MayThrowLegacyException] any getShaderParameter(WebGLShader? shader, GLenum pname);
+    [Custom] any getRenderbufferParameter(GLenum target, GLenum pname);
+    [Custom] any getShaderParameter(WebGLShader? shader, GLenum pname);
 
     DOMString? getShaderInfoLog(WebGLShader? shader);
 
@@ -573,13 +573,13 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
 
     [Custom] sequence<DOMString> getSupportedExtensions();
 
-    [Custom, MayThrowLegacyException] any getTexParameter(GLenum target, GLenum pname);
+    [Custom] any getTexParameter(GLenum target, GLenum pname);
 
-    [Custom, MayThrowLegacyException] any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
+    [Custom] any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
 
     WebGLUniformLocation getUniformLocation(WebGLProgram? program, DOMString name);
 
-    [Custom, MayThrowLegacyException] any getVertexAttrib(GLuint index, GLenum pname);
+    [Custom] any getVertexAttrib(GLuint index, GLenum pname);
 
     GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);
 
@@ -615,43 +615,35 @@ typedef (ImageData or HTMLImageElement or HTMLCanvasElement or HTMLVideoElement)
     void texParameteri(GLenum target, GLenum pname, GLint param);
 
     // Supported forms:
-    [MayThrowLegacyException] void texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);
-    [MayThrowLegacyException] void texImage2D(GLenum target, GLint level, GLenum internalformat, GLenum format, GLenum type, TexImageSource? source);
-
-    [MayThrowLegacyException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLsizei width, GLsizei height,
- GLenum format, GLenum type, ArrayBufferView? pixels);
-    [MayThrowLegacyException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLenum format, GLenum type, ImageData? pixels);
-    [MayThrowLegacyException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLenum format, GLenum type, HTMLImageElement? image);
-    [MayThrowLegacyException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLenum format, GLenum type, HTMLCanvasElement? canvas);
-#if defined(ENABLE_VIDEO) && ENABLE_VIDEO
-    [MayThrowLegacyException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
- GLenum format, GLenum type, HTMLVideoElement? video);
-#endif
+    void texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);
+    [MayThrowException] void texImage2D(GLenum target, GLint level, GLenum internalformat, GLenum format, GLenum type, TexImageSource? source);
+
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView? pixels);
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, ImageData? pixels);
+    [MayThrowException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, HTMLImageElement? image);
+    [MayThrowException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, HTMLCanvasElement? canvas);
+    [Conditional=VIDEO, MayThrowException] void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, HTMLVideoElement? video);
 
     void uniform1f(WebGLUniformLocation? location, GLfloat x);
-    [Custom, MayThrowLegacyException] void uniform1fv(WebGLUniformLocation? location, Float32Array v);
+    [Custom] void uniform1fv(WebGLUniformLocation? location, Float32Array v);
     void uniform1i(WebGLUniformLocation? location, GLint x);
-    [Custom, MayThrowLegacyException] void uniform1iv(WebGLUniformLocation? location, Int32Array v);
+    [Custom] void uniform1iv(WebGLUniformLocation? location, Int32Array v);
     void uniform2f(WebGLUniformLocation? location, GLfloat x, GLfloat y);
-    [Custom, MayThrowLegacyException] void uniform2fv(WebGLUniformLocation? location, Float32Array v);
+    [Custom] void uniform2fv(WebGLUniformLocation? location, Float32Array v);
     void uniform2i(WebGLUniformLocation? location, GLint x, GLint y);
-    [Custom, MayThrowLegacyException] void uniform2iv(WebGLUniformLocation? location, Int32Array v);
+    [Custom] void uniform2iv(WebGLUniformLocation? location, Int32Array v);
     void uniform3f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z);
-    [Custom, MayThrowLegacyException] void uniform3fv(WebGLUniformLocation? location, Float32Array v);
+    [Custom] void uniform3fv(WebGLUniformLocation? location, Float32Array v);
     void uniform3i(WebGLUniformLocation? location, GLint x, GLint y, GLint z);
-    [Custom, MayThrowLegacyException] void uniform3iv(WebGLUniformLocation? location, Int32Array v);
+    [Custom] void uniform3iv(WebGLUniformLocation? location, Int32Array v);
     void uniform4f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    [Custom, MayThrowLegacyException] void uniform4fv(WebGLUniformLocation? location, Float32Array v);
+    [Custom] void uniform4fv(WebGLUniformLocation? location, Float32Array v);
     void uniform4i(WebGLUniformLocation? location, GLint x, GLint y, GLint z, GLint w);
-    [Custom, MayThrowLegacyException] void uniform4iv(WebGLUniformLocation? location, Int32Array v);
+    [Custom] void uniform4iv(WebGLUniformLocation? location, Int32Array v);
 
-    [Custom, MayThrowLegacyException] void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
-    [Custom, MayThrowLegacyException] void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
-    [Custom, MayThrowLegacyException] void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
+    [Custom] void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
+    [Custom] void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
+    [Custom] void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, Float32Array array);
 
     void useProgram(WebGLProgram? program);
     void validateProgram(WebGLProgram? program);
index b7b705e..b4b06a2 100644 (file)
@@ -1172,7 +1172,7 @@ void MediaControlTextTrackContainerElement::updateDisplay()
 
         LOG(Media, "MediaControlTextTrackContainerElement::updateDisplay(%p) - adding and positioning cue #%zu: \"%s\", start=%.2f, end=%.2f, line=%.2f", this, i, cue->text().utf8().data(), cue->startTime(), cue->endTime(), cue->line());
 
-        RefPtr<VTTCueBox> displayBox = cue->getDisplayTree(m_videoDisplaySize.size(), m_fontSize);
+        Ref<VTTCueBox> displayBox = cue->getDisplayTree(m_videoDisplaySize.size(), m_fontSize);
         if (cue->track()->mode() == TextTrack::Mode::Disabled)
             continue;
 
@@ -1181,9 +1181,9 @@ void MediaControlTextTrackContainerElement::updateDisplay()
             // If cue has an empty text track cue region identifier or there is no
             // WebVTT region whose region identifier is identical to cue's text
             // track cue region identifier, run the following substeps:
-            if (displayBox->hasChildNodes() && !contains(displayBox.get())) {
+            if (displayBox->hasChildNodes() && !contains(displayBox.ptr())) {
                 // Note: the display tree of a cue is removed when the active flag of the cue is unset.
-                appendChild(*displayBox, ASSERT_NO_EXCEPTION);
+                appendChild(displayBox, ASSERT_NO_EXCEPTION);
                 cue->setFontSize(m_fontSize, m_videoDisplaySize.size(), m_fontSizeIsImportant);
             }
         } else {
@@ -1195,7 +1195,7 @@ void MediaControlTextTrackContainerElement::updateDisplay()
             if (!contains(regionNode.ptr()))
                 appendChild(region->getDisplayTree());
 
-            region->appendTextTrackCueBox(displayBox);
+            region->appendTextTrackCueBox(WTFMove(displayBox));
         }
     }
 
index 4410aec..0c867fa 100644 (file)
@@ -24,8 +24,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef DataCue_h
-#define DataCue_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
@@ -114,4 +113,3 @@ const DataCue* toDataCue(const TextTrackCue*);
 } // namespace WebCore
 
 #endif
-#endif
index 77f3361..358f7a7 100644 (file)
@@ -32,7 +32,7 @@
 #else
     CustomConstructor(unrestricted double startTime, unrestricted double endTime, ArrayBuffer data),
 #endif
-    ConstructorMayThrowLegacyException,
+    ConstructorMayThrowException,
 ] interface DataCue : TextTrackCue {
     attribute ArrayBuffer data;
 
index 7bf27ae..0e77b19 100644 (file)
@@ -25,9 +25,9 @@
  */
 
 #include "config.h"
+#include "InbandDataTextTrack.h"
 
 #if ENABLE(VIDEO_TRACK)
-#include "InbandDataTextTrack.h"
 
 #include "DataCue.h"
 #include "ExceptionCodePlaceholder.h"
 
 namespace WebCore {
 
-Ref<InbandDataTextTrack> InbandDataTextTrack::create(ScriptExecutionContext* context, TextTrackClient* client, PassRefPtr<InbandTextTrackPrivate> playerPrivate)
+Ref<InbandDataTextTrack> InbandDataTextTrack::create(ScriptExecutionContext* context, TextTrackClient* client, RefPtr<InbandTextTrackPrivate>&& trackPrivate)
 {
-    return adoptRef(*new InbandDataTextTrack(context, client, playerPrivate));
+    return adoptRef(*new InbandDataTextTrack(context, client, WTFMove(trackPrivate)));
 }
 
-InbandDataTextTrack::InbandDataTextTrack(ScriptExecutionContext* context, TextTrackClient* client, PassRefPtr<InbandTextTrackPrivate> trackPrivate)
+InbandDataTextTrack::InbandDataTextTrack(ScriptExecutionContext* context, TextTrackClient* client, RefPtr<InbandTextTrackPrivate>&& trackPrivate)
     : InbandTextTrack(context, client, trackPrivate)
 {
 }
@@ -54,11 +54,11 @@ InbandDataTextTrack::~InbandDataTextTrack()
 
 void InbandDataTextTrack::addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, const void* data, unsigned length)
 {
-    auto cue = DataCue::create(*scriptExecutionContext(), start, end, data, length);
-    addCue(WTFMove(cue), ASSERT_NO_EXCEPTION);
+    addCue(DataCue::create(*scriptExecutionContext(), start, end, data, length));
 }
 
 #if ENABLE(DATACUE_VALUE)
+
 void InbandDataTextTrack::addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation> prpPlatformValue, const String& type)
 {
     RefPtr<SerializedPlatformRepresentation> platformValue = prpPlatformValue;
@@ -76,7 +76,7 @@ void InbandDataTextTrack::addDataCue(InbandTextTrackPrivate*, const MediaTime& s
         m_incompleteCueMap.add(WTFMove(platformValue), cue.copyRef());
     }
 
-    addCue(WTFMove(cue), ASSERT_NO_EXCEPTION);
+    addCue(WTFMove(cue));
 }
 
 void InbandDataTextTrack::updateDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& inEnd, PassRefPtr<SerializedPlatformRepresentation> prpPlatformValue)
@@ -117,20 +117,17 @@ void InbandDataTextTrack::removeDataCue(InbandTextTrackPrivate*, const MediaTime
     RefPtr<DataCue> cue = iter->value;
     if (cue) {
         LOG(Media, "InbandDataTextTrack::removeDataCue removing cue: start=%s, end=%s\n", toString(cue->startTime()).utf8().data(), toString(cue->endTime()).utf8().data());
-        removeCue(cue.get(), IGNORE_EXCEPTION);
+        removeCue(cue.get());
     }
 }
 
-void InbandDataTextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
+ExceptionOr<void> InbandDataTextTrack::removeCue(TextTrackCue* cue)
 {
     ASSERT(cue->cueType() == TextTrackCue::Data);
 
-    SerializedPlatformRepresentation* platformValue = const_cast<SerializedPlatformRepresentation*>(toDataCue(cue)->platformValue());
-    auto iter = m_incompleteCueMap.find(platformValue);
-    if (iter != m_incompleteCueMap.end())
-        m_incompleteCueMap.remove(platformValue);
+    m_incompleteCueMap.remove(const_cast<SerializedPlatformRepresentation*>(toDataCue(cue)->platformValue()));
 
-    InbandTextTrack::removeCue(cue, ec);
+    return InbandTextTrack::removeCue(cue);
 }
 
 #endif
index 8be10ea..c9c42e3 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef InbandDataTextTrack_h
-#define InbandDataTextTrack_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
 #include "InbandTextTrack.h"
-#include <wtf/RefPtr.h>
 
 namespace WebCore {
 
 class DataCue;
-class Document;
 class InbandTextTrackPrivate;
-
-#if ENABLE(DATACUE_VALUE)
 class SerializedPlatformRepresentation;
-#endif
 
 class InbandDataTextTrack final : public InbandTextTrack {
 public:
-    static Ref<InbandDataTextTrack> create(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
+    static Ref<InbandDataTextTrack> create(ScriptExecutionContext*, TextTrackClient*, RefPtr<InbandTextTrackPrivate>&&);
     virtual ~InbandDataTextTrack();
 
 private:
-    InbandDataTextTrack(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
+    InbandDataTextTrack(ScriptExecutionContext*, TextTrackClient*, RefPtr<InbandTextTrackPrivate>&&);
 
-    void addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, const void*, unsigned) override;
+    void addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, const void*, unsigned) final;
 
 #if ENABLE(DATACUE_VALUE)
-    void addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>, const String&) override;
-    void updateDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>) override;
-    void removeDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>) override;
-    void removeCue(TextTrackCue*, ExceptionCode&) override;
+    void addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>, const String&) final;
+    void updateDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>) final;
+    void removeDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation>) final;
+    ExceptionOr<void> removeCue(TextTrackCue*) final;
 
     HashMap<RefPtr<SerializedPlatformRepresentation>, RefPtr<DataCue>> m_incompleteCueMap;
 #endif
@@ -65,4 +59,3 @@ private:
 } // namespace WebCore
 
 #endif
-#endif
index 7dc027c..f32fb1e 100644 (file)
  */
 
 #include "config.h"
+#include "InbandGenericTextTrack.h"
 
 #if ENABLE(VIDEO_TRACK)
 
-#include "InbandGenericTextTrack.h"
-
 #include "ExceptionCodePlaceholder.h"
 #include "HTMLMediaElement.h"
 #include "InbandTextTrackPrivate.h"
 #include <math.h>
 #include <wtf/text/CString.h>
 
-
 namespace WebCore {
 
-GenericTextTrackCueMap::GenericTextTrackCueMap()
+void GenericTextTrackCueMap::add(GenericCueData& cueData, TextTrackCueGeneric& cue)
 {
+    m_dataToCueMap.add(&cueData, &cue);
+    m_cueToDataMap.add(&cue, &cueData);
 }
 
-GenericTextTrackCueMap::~GenericTextTrackCueMap()
+TextTrackCueGeneric* GenericTextTrackCueMap::find(GenericCueData& cueData)
 {
+    return m_dataToCueMap.get(&cueData);
 }
 
-void GenericTextTrackCueMap::add(GenericCueData* cueData, TextTrackCueGeneric* cue)
+GenericCueData* GenericTextTrackCueMap::find(TextTrackCue& cue)
 {
-    m_dataToCueMap.add(cueData, cue);
-    m_cueToDataMap.add(cue, cueData);
-}
-
-PassRefPtr<TextTrackCueGeneric> GenericTextTrackCueMap::find(GenericCueData* cueData)
-{
-    CueDataToCueMap::iterator iter = m_dataToCueMap.find(cueData);
-    if (iter == m_dataToCueMap.end())
-        return 0;
-
-    return iter->value;
+    return m_cueToDataMap.get(&cue);
 }
 
-PassRefPtr<GenericCueData> GenericTextTrackCueMap::find(TextTrackCue* cue)
+void GenericTextTrackCueMap::remove(GenericCueData& cueData)
 {
-    CueToDataMap::iterator iter = m_cueToDataMap.find(cue);
-    if (iter == m_cueToDataMap.end())
-        return 0;
-
-    return iter->value;
-}
-
-void GenericTextTrackCueMap::remove(GenericCueData* cueData)
-{
-    RefPtr<TextTrackCueGeneric> cue = find(cueData);
-
-    if (cue)
+    if (auto cue = m_dataToCueMap.take(&cueData))
         m_cueToDataMap.remove(cue);
-    m_dataToCueMap.remove(cueData);
 }
 
-void GenericTextTrackCueMap::remove(TextTrackCue* cue)
+void GenericTextTrackCueMap::remove(TextTrackCue& cue)
 {
-    RefPtr<GenericCueData> genericData = find(cue);
-    if (genericData) {
-        m_dataToCueMap.remove(genericData);
-        m_cueToDataMap.remove(cue);
-    }
+    if (auto data = m_cueToDataMap.take(&cue))
+        m_dataToCueMap.remove(data);
 }
 
 Ref<InbandGenericTextTrack> InbandGenericTextTrack::create(ScriptExecutionContext* context, TextTrackClient* client, PassRefPtr<InbandTextTrackPrivate> playerPrivate)
@@ -120,11 +96,11 @@ void InbandGenericTextTrack::updateCueFromCueData(TextTrackCueGeneric* cue, Gene
     cue->setFontName(cueData->fontName());
 
     if (cueData->position() > 0)
-        cue->setPosition(lround(cueData->position()), IGNORE_EXCEPTION);
+        cue->setPosition(std::round(cueData->position()));
     if (cueData->line() > 0)
-        cue->setLine(lround(cueData->line()), IGNORE_EXCEPTION);
+        cue->setLine(std::round(cueData->line()));
     if (cueData->size() > 0)
-        cue->setSize(lround(cueData->size()), IGNORE_EXCEPTION);
+        cue->setSize(std::round(cueData->size()));
     if (cueData->backgroundColor().isValid())
         cue->setBackgroundColor(cueData->backgroundColor().rgb());
     if (cueData->foregroundColor().isValid())
@@ -133,11 +109,11 @@ void InbandGenericTextTrack::updateCueFromCueData(TextTrackCueGeneric* cue, Gene
         cue->setHighlightColor(cueData->highlightColor().rgb());
 
     if (cueData->align() == GenericCueData::Start)
-        cue->setAlign(ASCIILiteral("start"), IGNORE_EXCEPTION);
+        cue->setAlign(ASCIILiteral("start"));
     else if (cueData->align() == GenericCueData::Middle)
-        cue->setAlign(ASCIILiteral("middle"), IGNORE_EXCEPTION);
+        cue->setAlign(ASCIILiteral("middle"));
     else if (cueData->align() == GenericCueData::End)
-        cue->setAlign(ASCIILiteral("end"), IGNORE_EXCEPTION);
+        cue->setAlign(ASCIILiteral("end"));
     cue->setSnapToLines(false);
 
     cue->didChange();
@@ -148,7 +124,7 @@ void InbandGenericTextTrack::addGenericCue(InbandTextTrackPrivate* trackPrivate,
     ASSERT_UNUSED(trackPrivate, trackPrivate == m_private);
 
     RefPtr<GenericCueData> cueData = prpCueData;
-    if (m_cueMap.find(cueData.get()))
+    if (m_cueMap.find(*cueData))
         return;
 
     RefPtr<TextTrackCueGeneric> cue = TextTrackCueGeneric::create(*scriptExecutionContext(), cueData->startTime(), cueData->endTime(), cueData->content());
@@ -161,39 +137,40 @@ void InbandGenericTextTrack::addGenericCue(InbandTextTrackPrivate* trackPrivate,
     LOG(Media, "InbandGenericTextTrack::addGenericCue added cue: start=%.2f, end=%.2f, content=\"%s\"\n", cueData->startTime().toDouble(), cueData->endTime().toDouble(), cueData->content().utf8().data());
 
     if (cueData->status() != GenericCueData::Complete)
-        m_cueMap.add(cueData.get(), cue.get());
+        m_cueMap.add(*cueData, *cue);
 
-    addCue(cue, ASSERT_NO_EXCEPTION);
+    addCue(WTFMove(cue));
 }
 
 void InbandGenericTextTrack::updateGenericCue(InbandTextTrackPrivate*, GenericCueData* cueData)
 {
-    RefPtr<TextTrackCueGeneric> cue = m_cueMap.find(cueData);
+    auto* cue = m_cueMap.find(*cueData);
     if (!cue)
         return;
 
-    updateCueFromCueData(cue.get(), cueData);
+    updateCueFromCueData(cue, cueData);
 
     if (cueData->status() == GenericCueData::Complete)
-        m_cueMap.remove(cueData);
+        m_cueMap.remove(*cueData);
 }
 
 void InbandGenericTextTrack::removeGenericCue(InbandTextTrackPrivate*, GenericCueData* cueData)
 {
-    RefPtr<TextTrackCueGeneric> cue = m_cueMap.find(cueData);
+    auto* cue = m_cueMap.find(*cueData);
     if (cue) {
         LOG(Media, "InbandGenericTextTrack::removeGenericCue removing cue: start=%s, end=%s, content=\"%s\"\n",  toString(cueData->startTime()).utf8().data(), toString(cueData->endTime()).utf8().data(), cueData->content().utf8().data());
-        removeCue(cue.get(), IGNORE_EXCEPTION);
+        removeCue(cue);
     } else {
         LOG(Media, "InbandGenericTextTrack::removeGenericCue UNABLE to find cue: start=%.2f, end=%.2f, content=\"%s\"\n", cueData->startTime().toDouble(), cueData->endTime().toDouble(), cueData->content().utf8().data());
-        m_cueMap.remove(cueData);
     }
 }
 
-void InbandGenericTextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
+ExceptionOr<void> InbandGenericTextTrack::removeCue(TextTrackCue* cue)
 {
-    m_cueMap.remove(cue);
-    TextTrack::removeCue(cue, ec);
+    auto result = TextTrack::removeCue(cue);
+    if (!result.hasException() && cue)
+        m_cueMap.remove(*cue);
+    return result;
 }
 
 WebVTTParser& InbandGenericTextTrack::parser()
@@ -227,7 +204,7 @@ void InbandGenericTextTrack::newCuesParsed()
             LOG(Media, "InbandGenericTextTrack::newCuesParsed ignoring already added cue: start=%.2f, end=%.2f, content=\"%s\"\n", vttCue->startTime(), vttCue->endTime(), vttCue->text().utf8().data());
             return;
         }
-        addCue(WTFMove(vttCue), ASSERT_NO_EXCEPTION);
+        addCue(WTFMove(vttCue));
     }
 }
 
index 72b05fd..dce135e 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef InbandGenericTextTrack_h
-#define InbandGenericTextTrack_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
 #include "InbandTextTrack.h"
 #include "TextTrackCueGeneric.h"
 #include "WebVTTParser.h"
-#include <wtf/RefPtr.h>
 
 namespace WebCore {
 
 class Document;
 class InbandTextTrackPrivate;
-class TextTrackCue;
 
-class GenericTextTrackCueMap final {
+class GenericTextTrackCueMap {
 public:
-    GenericTextTrackCueMap();
-    ~GenericTextTrackCueMap();
+    void add(GenericCueData&, TextTrackCueGeneric&);
 
-    void add(GenericCueData*, TextTrackCueGeneric*);
+    void remove(TextTrackCue&);
+    void remove(GenericCueData&);
 
-    void remove(TextTrackCue*);
-    void remove(GenericCueData*);
-
-    PassRefPtr<GenericCueData> find(TextTrackCue*);
-    PassRefPtr<TextTrackCueGeneric> find(GenericCueData*);
+    GenericCueData* find(TextTrackCue&);
+    TextTrackCueGeneric* find(GenericCueData&);
 
 private:
-    typedef HashMap<RefPtr<TextTrackCue>, RefPtr<GenericCueData>> CueToDataMap;
-    typedef HashMap<RefPtr<GenericCueData>, RefPtr<TextTrackCueGeneric>> CueDataToCueMap;
+    using CueToDataMap = HashMap<RefPtr<TextTrackCue>, RefPtr<GenericCueData>>;
+    using CueDataToCueMap = HashMap<RefPtr<GenericCueData>, RefPtr<TextTrackCueGeneric>>;
 
     CueToDataMap m_cueToDataMap;
     CueDataToCueMap m_dataToCueMap;
@@ -68,21 +62,21 @@ public:
 private:
     InbandGenericTextTrack(ScriptExecutionContext*, TextTrackClient*, PassRefPtr<InbandTextTrackPrivate>);
 
-    void addGenericCue(InbandTextTrackPrivate*, PassRefPtr<GenericCueData>) override;
-    void updateGenericCue(InbandTextTrackPrivate*, GenericCueData*) override;
-    void removeGenericCue(InbandTextTrackPrivate*, GenericCueData*) override;
-    void removeCue(TextTrackCue*, ExceptionCode&) override;
+    void addGenericCue(InbandTextTrackPrivate*, PassRefPtr<GenericCueData>) final;
+    void updateGenericCue(InbandTextTrackPrivate*, GenericCueData*) final;
+    void removeGenericCue(InbandTextTrackPrivate*, GenericCueData*) final;
+    ExceptionOr<void> removeCue(TextTrackCue*) final;
 
     PassRefPtr<TextTrackCueGeneric> createCue(PassRefPtr<GenericCueData>);
     void updateCueFromCueData(TextTrackCueGeneric*, GenericCueData*);
 
     WebVTTParser& parser();
-    void parseWebVTTCueData(InbandTextTrackPrivate*, const ISOWebVTTCue&) override;
-    void parseWebVTTFileHeader(InbandTextTrackPrivate*, String) override;
+    void parseWebVTTCueData(InbandTextTrackPrivate*, const ISOWebVTTCue&) final;
+    void parseWebVTTFileHeader(InbandTextTrackPrivate*, String) final;
 
-    void newCuesParsed() override;
-    void newRegionsParsed() override;
-    void fileFailedToParse() override;
+    void newCuesParsed() final;
+    void newRegionsParsed() final;
+    void fileFailedToParse() final;
 
     GenericTextTrackCueMap m_cueMap;
     std::unique_ptr<WebVTTParser> m_webVTTParser;
@@ -91,4 +85,3 @@ private:
 } // namespace WebCore
 
 #endif
-#endif
index 99b4945..e540e49 100644 (file)
@@ -82,7 +82,7 @@ void InbandWebVTTTextTrack::newCuesParsed()
             LOG(Media, "InbandWebVTTTextTrack::newCuesParsed ignoring already added cue: start=%.2f, end=%.2f, content=\"%s\"\n", vttCue->startTime(), vttCue->endTime(), vttCue->text().utf8().data());
             return;
         }
-        addCue(WTFMove(vttCue), ASSERT_NO_EXCEPTION);
+        addCue(WTFMove(vttCue));
     }
 }
     
index fc8e203..8418058 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2011, 2013 Google Inc.  All rights reserved.
- * Copyright (C) 2011-2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2011, 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2011-2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -85,13 +85,13 @@ static const AtomicString& forcedKeyword()
 
 TextTrack* TextTrack::captionMenuOffItem()
 {
-    static TextTrack& off = TextTrack::create(0, 0, "off menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
+    static TextTrack& off = TextTrack::create(nullptr, nullptr, "off menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
     return &off;
 }
 
 TextTrack* TextTrack::captionMenuAutomaticItem()
 {
-    static TextTrack& automatic = TextTrack::create(0, 0, "automatic menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
+    static TextTrack& automatic = TextTrack::create(nullptr, nullptr, "automatic menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
     return &automatic;
 }
 
@@ -290,12 +290,10 @@ TextTrackCueList* TextTrack::activeCues() const
     return m_cues->activeCues();
 }
 
-void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
+ExceptionOr<void> TextTrack::addCue(RefPtr<TextTrackCue>&& cue)
 {
-    if (!prpCue)
-        return;
-
-    RefPtr<TextTrackCue> cue = prpCue;
+    if (!cue)
+        return { };
 
     // 4.7.10.12.6 Text tracks exposing in-band metadata
     // The UA will use DataCue to expose only text track cue objects that belong to a text track that has a text
@@ -303,14 +301,12 @@ void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
     // If a DataCue is added to a TextTrack via the addCue() method but the text track does not have its text
     // track kind set to metadata, throw a InvalidNodeTypeError exception and don't add the cue to the TextTrackList
     // of the TextTrack.
-    if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata) {
-        ec = INVALID_NODE_TYPE_ERR;
-        return;
-    }
+    if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata)
+        return Exception { INVALID_NODE_TYPE_ERR };
 
     // TODO(93143): Add spec-compliant behavior for negative time values.
     if (!cue->startMediaTime().isValid() || !cue->endMediaTime().isValid() || cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
-        return;
+        return { };
 
     // 4.8.10.12.5 Text track API
 
@@ -320,7 +316,7 @@ void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
     // list of cues.
     TextTrack* cueTrack = cue->track();
     if (cueTrack && cueTrack != this)
-        cueTrack->removeCue(cue.get(), ASSERT_NO_EXCEPTION);
+        cueTrack->removeCue(cue.get());
 
     // 2. Add cue to the method's TextTrack object's text track's text track list of cues.
     cue->setTrack(this);
@@ -328,12 +324,14 @@ void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
     
     if (m_client)
         m_client->textTrackAddCue(this, *cue);
+
+    return { };
 }
 
-void TextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
+ExceptionOr<void> TextTrack::removeCue(TextTrackCue* cue)
 {
     if (!cue)
-        return;
+        return { };
 
     // 4.8.10.12.5 Text track API
 
@@ -341,20 +339,18 @@ void TextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
 
     // 1. If the given cue is not currently listed in the method's TextTrack 
     // object's text track's text track list of cues, then throw a NotFoundError exception.
-    if (cue->track() != this) {
-        ec = NOT_FOUND_ERR;
-        return;
-    }
+    if (cue->track() != this)
+        return Exception { NOT_FOUND_ERR };
 
     // 2. Remove cue from the method's TextTrack object's text track's text track list of cues.
-    if (!m_cues || !m_cues->remove(cue)) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
+    if (!m_cues || !m_cues->remove(cue))
+        return Exception { INVALID_STATE_ERR };
 
-    cue->setTrack(0);
+    cue->setTrack(nullptr);
     if (m_client)
         m_client->textTrackRemoveCue(this, *cue);
+
+    return { };
 }
 
 VTTRegionList& TextTrack::ensureVTTRegionList()
@@ -378,54 +374,50 @@ VTTRegionList* TextTrack::regions()
     return &ensureVTTRegionList();
 }
 
-void TextTrack::addRegion(PassRefPtr<VTTRegion> prpRegion)
+void TextTrack::addRegion(RefPtr<VTTRegion>&& region)
 {
-    if (!prpRegion)
+    if (!region)
         return;
 
-    RefPtr<VTTRegion> region = prpRegion;
-    VTTRegionList& regionList = ensureVTTRegionList();
+    auto& regionList = ensureVTTRegionList();
 
     // 1. If the given region is in a text track list of regions, then remove
     // region from that text track list of regions.
-    TextTrack* regionTrack = region->track();
+    auto* regionTrack = region->track();
     if (regionTrack && regionTrack != this)
-        regionTrack->removeRegion(region.get(), ASSERT_NO_EXCEPTION);
+        regionTrack->removeRegion(region.get());
 
     // 2. If the method's TextTrack object's text track list of regions contains
     // a region with the same identifier as region replace the values of that
     // region's width, height, anchor point, viewport anchor point and scroll
     // attributes with those of region.
-    VTTRegion* existingRegion = regionList.getRegionById(region->id());
+    auto* existingRegion = regionList.getRegionById(region->id());
     if (existingRegion) {
-        existingRegion->updateParametersFromRegion(region.get());
+        existingRegion->updateParametersFromRegion(*region);
         return;
     }
 
     // Otherwise: add region to the method's TextTrack object's text track
     // list of regions.
     region->setTrack(this);
-    regionList.add(region);
+    regionList.add(WTFMove(region));
 }
 
-void TextTrack::removeRegion(VTTRegion* region, ExceptionCode &ec)
+ExceptionOr<void> TextTrack::removeRegion(VTTRegion* region)
 {
     if (!region)
-        return;
+        return { };
 
     // 1. If the given region is not currently listed in the method's TextTrack
     // object's text track list of regions, then throw a NotFoundError exception.
-    if (region->track() != this) {
-        ec = NOT_FOUND_ERR;
-        return;
-    }
+    if (region->track() != this)
+        return Exception { NOT_FOUND_ERR };
 
-    if (!m_regions || !m_regions->remove(region)) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
+    if (!m_regions || !m_regions->remove(region))
+        return Exception { INVALID_STATE_ERR };
 
-    region->setTrack(0);
+    region->setTrack(nullptr);
+    return { };
 }
 
 void TextTrack::cueWillChange(TextTrackCue* cue)
index f1e216b..6f8a530 100644 (file)
@@ -100,14 +100,14 @@ public:
     void clearClient() override { m_client = nullptr; }
     TextTrackClient* client() { return m_client; }
 
-    void addCue(PassRefPtr<TextTrackCue>, ExceptionCode&);
-    virtual void removeCue(TextTrackCue*, ExceptionCode&);
+    ExceptionOr<void> addCue(RefPtr<TextTrackCue>&&);
+    virtual ExceptionOr<void> removeCue(TextTrackCue*);
 
     bool hasCue(TextTrackCue*, TextTrackCue::CueMatchRules = TextTrackCue::MatchAllFields);
 
     VTTRegionList* regions();
-    void addRegion(PassRefPtr<VTTRegion>);
-    void removeRegion(VTTRegion*, ExceptionCode&);
+    void addRegion(RefPtr<VTTRegion>&&);
+    ExceptionOr<void> removeRegion(VTTRegion*);
 
     void cueWillChange(TextTrackCue*);
     void cueDidChange(TextTrackCue*);
index 97dae9d..106d157 100644 (file)
@@ -44,13 +44,13 @@ enum TextTrackKind { "subtitles", "captions", "descriptions", "chapters", "metad
     readonly attribute TextTrackCueList? activeCues;
 
     // FIXME: cue parameter should not be nullable in addCue and removeCue.
-    [MayThrowLegacyException] void addCue(TextTrackCue? cue);
-    [MayThrowLegacyException] void removeCue(TextTrackCue? cue);
+    [MayThrowException] void addCue(TextTrackCue? cue);
+    [MayThrowException] void removeCue(TextTrackCue? cue);
 
     attribute EventHandler oncuechange;
 
     readonly attribute VTTRegionList regions;
     // FIXME: region parameter should not be nullable in addRegion and removeRegion.
     void addRegion(VTTRegion? region);
-    [MayThrowLegacyException] void removeRegion(VTTRegion? region);
+    [MayThrowException] void removeRegion(VTTRegion? region);
 };
index e9112ef..4a85719 100644 (file)
@@ -54,6 +54,12 @@ namespace WebCore {
 
 static const int invalidCueIndex = -1;
 
+const AtomicString& TextTrackCue::cueShadowPseudoId()
+{
+    static NeverDestroyed<const AtomicString> cue("cue", AtomicString::ConstructFromLiteral);
+    return cue;
+}
+
 TextTrackCue::TextTrackCue(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end)
     : m_startTime(start)
     , m_endTime(end)
@@ -67,10 +73,6 @@ TextTrackCue::TextTrackCue(ScriptExecutionContext& context, const MediaTime& sta
     ASSERT(m_scriptExecutionContext.isDocument());
 }
 
-TextTrackCue::~TextTrackCue()
-{
-}
-
 void TextTrackCue::willChange()
 {
     if (++m_processingCueChanges > 1)
@@ -110,14 +112,8 @@ void TextTrackCue::setId(const String& id)
     didChange();
 }
 
-void TextTrackCue::setStartTime(double value, ExceptionCode& ec)
+void TextTrackCue::setStartTime(double value)
 {
-    // NaN, Infinity and -Infinity values should trigger a TypeError.
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-    
     // TODO(93143): Add spec-compliant behavior for negative time values.
     if (m_startTime.toDouble() == value || value < 0)
         return;
@@ -132,14 +128,8 @@ void TextTrackCue::setStartTime(const MediaTime& value)
     didChange();
 }
     
-void TextTrackCue::setEndTime(double value, ExceptionCode& ec)
+void TextTrackCue::setEndTime(double value)
 {
-    // NaN, Infinity and -Infinity values should trigger a TypeError.
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
     // TODO(93143): Add spec-compliant behavior for negative time values.
     if (m_endTime.toDouble() == value || value < 0)
         return;
index 1ea03d0..57351dc 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2011 Google Inc.  All rights reserved.
- * Copyright (C) 2012, 2013, 2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2011 Google Inc. All rights reserved.
+ * Copyright (C) 2012, 2013, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TextTrackCue_h
-#define TextTrackCue_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
-#include "EventTarget.h"
-#include "HTMLElement.h"
+#include "Document.h"
 #include <wtf/MediaTime.h>
-#include <wtf/NeverDestroyed.h>
-#include <wtf/RefCounted.h>
 
 namespace WebCore {
 
@@ -46,13 +42,7 @@ class TextTrack;
 
 class TextTrackCue : public RefCounted<TextTrackCue>, public EventTargetWithInlineData {
 public:
-    static const AtomicString& cueShadowPseudoId()
-    {
-        static NeverDestroyed<const AtomicString> cue("cue", AtomicString::ConstructFromLiteral);
-        return cue;
-    }
-
-    virtual ~TextTrackCue();
+    static const AtomicString& cueShadowPseudoId();
 
     TextTrack* track() const;
     void setTrack(TextTrack*);
@@ -60,57 +50,48 @@ public:
     const String& id() const { return m_id; }
     void setId(const String&);
 
-    MediaTime startMediaTime() const { return m_startTime; }
     double startTime() const { return startMediaTime().toDouble(); }
-    void setStartTime(const MediaTime&);
-    void setStartTime(double, ExceptionCode&);
+    void setStartTime(double);
 
-    MediaTime endMediaTime() const { return m_endTime; }
     double endTime() const { return endMediaTime().toDouble(); }
-    void setEndTime(const MediaTime&);
-    void setEndTime(double, ExceptionCode&);
+    void setEndTime(double);
 
     bool pauseOnExit() const { return m_pauseOnExit; }
     void setPauseOnExit(bool);
 
+    MediaTime startMediaTime() const { return m_startTime; }
+    void setStartTime(const MediaTime&);
+
+    MediaTime endMediaTime() const { return m_endTime; }
+    void setEndTime(const MediaTime&);
+
     int cueIndex();
     void invalidateCueIndex();
 
-    using EventTarget::dispatchEvent;
-    bool dispatchEvent(Event&) override;
-
     bool isActive();
     virtual void setIsActive(bool);
 
-    EventTargetInterface eventTargetInterface() const final { return TextTrackCueEventTargetInterfaceType; }
-    ScriptExecutionContext* scriptExecutionContext() const final { return &m_scriptExecutionContext; }
-
     virtual bool isOrderedBefore(const TextTrackCue*) const;
     virtual bool isPositionedAbove(const TextTrackCue* cue) const { return isOrderedBefore(cue); }
 
     bool hasEquivalentStartTime(const TextTrackCue&) const;
 
-    enum CueType {
-        Data,
-        Generic,
-        WebVTT
-    };
+    enum CueType { Data, Generic, WebVTT };
     virtual CueType cueType() const = 0;
     virtual bool isRenderable() const { return false; }
 
-    enum CueMatchRules {
-        MatchAllFields,
-        IgnoreDuration,
-    };
+    enum CueMatchRules { MatchAllFields, IgnoreDuration };
     virtual bool isEqual(const TextTrackCue&, CueMatchRules) const;
+private:
     virtual bool cueContentsMatch(const TextTrackCue&) const;
+public:
     virtual bool doesExtendCue(const TextTrackCue&) const;
 
     void willChange();
     virtual void didChange();
 
-    using RefCounted<TextTrackCue>::ref;
-    using RefCounted<TextTrackCue>::deref;
+    using RefCounted::ref;
+    using RefCounted::deref;
 
 protected:
     TextTrackCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end);
@@ -118,10 +99,15 @@ protected:
     Document& ownerDocument() { return downcast<Document>(m_scriptExecutionContext); }
 
 private:
-
     void refEventTarget() final { ref(); }
     void derefEventTarget() final { deref(); }
 
+    using EventTarget::dispatchEvent;
+    bool dispatchEvent(Event&) final;
+
+    EventTargetInterface eventTargetInterface() const final { return TextTrackCueEventTargetInterfaceType; }
+    ScriptExecutionContext* scriptExecutionContext() const final { return &m_scriptExecutionContext; }
+
     String m_id;
     MediaTime m_startTime;
     MediaTime m_endTime;
@@ -139,4 +125,3 @@ private:
 } // namespace WebCore
 
 #endif
-#endif
index 705aebf..44fe168 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Google Inc.  All rights reserved.
+ * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 
 [
     Conditional=VIDEO_TRACK,
-    JSCustomMarkFunction,
     CustomIsReachable,
     CustomToJSObject,
+    JSCustomMarkFunction,
     SkipVTableValidation,
 ] interface TextTrackCue : EventTarget {
     readonly attribute TextTrack track;
 
     attribute DOMString id;
-    [SetterMayThrowLegacyException] attribute unrestricted double startTime;
-    [SetterMayThrowLegacyException] attribute unrestricted double endTime;
+    attribute double startTime;
+    attribute double endTime;
     attribute boolean pauseOnExit;
 
     attribute EventHandler onenter;
     attribute EventHandler onexit;
 };
-
index f66ec74..145f4a9 100644 (file)
@@ -71,7 +71,7 @@ void TextTrackCueGenericBoxElement::applyCSSProperties(const IntSize& videoSize)
     setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
     
     TextTrackCueGeneric* cue = static_cast<TextTrackCueGeneric*>(getCue());
-    RefPtr<HTMLSpanElement> cueElement = cue->element();
+    Ref<HTMLSpanElement> cueElement = cue->element();
 
     CSSValueID alignment = cue->getCSSAlignment();
     float size = static_cast<float>(cue->getCSSSize());
@@ -148,25 +148,28 @@ TextTrackCueGeneric::TextTrackCueGeneric(ScriptExecutionContext& context, const
     : VTTCue(context, start, end, content)
     , m_baseFontSizeRelativeToVideoHeight(0)
     , m_fontSizeMultiplier(0)
-    , m_defaultPosition(true)
 {
 }
 
-PassRefPtr<VTTCueBox> TextTrackCueGeneric::createDisplayTree()
+Ref<VTTCueBox> TextTrackCueGeneric::createDisplayTree()
 {
     return TextTrackCueGenericBoxElement::create(ownerDocument(), *this);
 }
 
-void TextTrackCueGeneric::setLine(double line, ExceptionCode& ec)
+ExceptionOr<void> TextTrackCueGeneric::setLine(double line)
 {
-    m_defaultPosition = false;
-    VTTCue::setLine(line, ec);
+    auto result = VTTCue::setLine(line);
+    if (!result.hasException())
+        m_useDefaultPosition = false;
+    return result;
 }
 
-void TextTrackCueGeneric::setPosition(double position, ExceptionCode& ec)
+ExceptionOr<void> TextTrackCueGeneric::setPosition(double position)
 {
-    m_defaultPosition = false;
-    VTTCue::setPosition(position, ec);
+    auto result = VTTCue::setPosition(position);
+    if (!result.hasException())
+        m_useDefaultPosition = false;
+    return result;
 }
 
 void TextTrackCueGeneric::setFontSize(int fontSize, const IntSize& videoSize, bool important)
@@ -182,7 +185,7 @@ void TextTrackCueGeneric::setFontSize(int fontSize, const IntSize& videoSize, bo
     double size = videoSize.height() * baseFontSizeRelativeToVideoHeight() / 100;
     if (fontSizeMultiplier())
         size *= fontSizeMultiplier() / 100;
-    displayTreeInternal()->setInlineStyleProperty(CSSPropertyFontSize, lround(size), CSSPrimitiveValue::CSS_PX);
+    displayTreeInternal().setInlineStyleProperty(CSSPropertyFontSize, lround(size), CSSPrimitiveValue::CSS_PX);
 
     LOG(Media, "TextTrackCueGeneric::setFontSize - setting cue font size to %li", lround(size));
 }
index 856115b..6c281eb 100644 (file)
@@ -23,8 +23,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TextTrackCueGeneric_h
-#define TextTrackCueGeneric_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
@@ -42,58 +41,55 @@ public:
     {
         return adoptRef(*new TextTrackCueGeneric(context, start, end, content));
     }
-    
-    virtual ~TextTrackCueGeneric() { }
 
-    PassRefPtr<VTTCueBox> createDisplayTree() override;
+    ExceptionOr<void> setLine(double) final;
+    ExceptionOr<void> setPosition(double) final;
 
-    void setLine(double, ExceptionCode&) override;
-    void setPosition(double, ExceptionCode&) override;
+    bool useDefaultPosition() const { return m_useDefaultPosition; }
 
-    bool useDefaultPosition() const { return m_defaultPosition; }
-    
     double baseFontSizeRelativeToVideoHeight() const { return m_baseFontSizeRelativeToVideoHeight; }
     void setBaseFontSizeRelativeToVideoHeight(double size) { m_baseFontSizeRelativeToVideoHeight = size; }
 
     double fontSizeMultiplier() const { return m_fontSizeMultiplier; }
     void setFontSizeMultiplier(double size) { m_fontSizeMultiplier = size; }
 
-    String fontName() const { return m_fontName; }
-    void setFontName(String name) { m_fontName = name; }
+    const String& fontName() const { return m_fontName; }
+    void setFontName(const String& name) { m_fontName = name; }
 
     const Color& foregroundColor() const { return m_foregroundColor; }
-    void setForegroundColor(Color color) { m_foregroundColor = color; }
+    void setForegroundColor(const Color& color) { m_foregroundColor = color; }
     
     const Color& backgroundColor() const { return m_backgroundColor; }
-    void setBackgroundColor(Color color) { m_backgroundColor = color; }
+    void setBackgroundColor(const Color& color) { m_backgroundColor = color; }
     
     const Color& highlightColor() const { return m_highlightColor; }
-    void setHighlightColor(Color color) { m_highlightColor = color; }
-    
-    void setFontSize(int, const IntSize&, bool important) override;
+    void setHighlightColor(const Color& color) { m_highlightColor = color; }
 
-    bool isEqual(const TextTrackCue&, CueMatchRules) const override;
-    bool cueContentsMatch(const TextTrackCue&) const override;
-    bool doesExtendCue(const TextTrackCue&) const override;
-
-    TextTrackCue::CueType cueType() const override { return TextTrackCue::Generic; }
+    void setFontSize(int, const IntSize&, bool important) final;
 
 private:
-    bool isOrderedBefore(const TextTrackCue*) const override;
-    bool isPositionedAbove(const TextTrackCue*) const override;
-
     TextTrackCueGeneric(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String&);
     
+    bool isOrderedBefore(const TextTrackCue*) const final;
+    bool isPositionedAbove(const TextTrackCue*) const final;
+
+    Ref<VTTCueBox> createDisplayTree() final;
+
+    bool isEqual(const TextTrackCue&, CueMatchRules) const final;
+    bool cueContentsMatch(const TextTrackCue&) const final;
+    bool doesExtendCue(const TextTrackCue&) const final;
+
+    CueType cueType() const final { return Generic; }
+
     Color m_foregroundColor;
     Color m_backgroundColor;
     Color m_highlightColor;
-    double m_baseFontSizeRelativeToVideoHeight;
-    double m_fontSizeMultiplier;
+    double m_baseFontSizeRelativeToVideoHeight { 0 };
+    double m_fontSizeMultiplier { 0 };
     String m_fontName;
-    bool m_defaultPosition;
+    bool m_useDefaultPosition { true };
 };
 
 } // namespace WebCore
 
 #endif
-#endif
index a73f655..f9b5be1 100644 (file)
@@ -292,16 +292,16 @@ void VTTCue::initialize(ScriptExecutionContext& context)
     m_originalStartTime = MediaTime::zeroTime();
 }
 
-PassRefPtr<VTTCueBox> VTTCue::createDisplayTree()
+Ref<VTTCueBox> VTTCue::createDisplayTree()
 {
     return VTTCueBox::create(ownerDocument(), *this);
 }
 
-VTTCueBox* VTTCue::displayTreeInternal()
+VTTCueBox& VTTCue::displayTreeInternal()
 {
     if (!m_displayTree)
         m_displayTree = createDisplayTree();
-    return m_displayTree.get();
+    return *m_displayTree;
 }
 
 void VTTCue::didChange()
@@ -325,7 +325,7 @@ const String& VTTCue::vertical() const
     }
 }
 
-void VTTCue::setVertical(const String& value, ExceptionCode& ec)
+ExceptionOr<void> VTTCue::setVertical(const String& value)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-vertical
     // On setting, the text track cue writing direction must be set to the value given 
@@ -341,14 +341,16 @@ void VTTCue::setVertical(const String& value, ExceptionCode& ec)
     else if (value == verticalGrowingRightKeyword())
         direction = VerticalGrowingRight;
     else
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
     
     if (direction == m_writingDirection)
-        return;
+        return { };
 
     willChange();
     m_writingDirection = direction;
     didChange();
+
+    return { };
 }
 
 void VTTCue::setSnapToLines(bool value)
@@ -361,62 +363,62 @@ void VTTCue::setSnapToLines(bool value)
     didChange();
 }
 
-void VTTCue::setLine(double position, ExceptionCode& ec)
+ExceptionOr<void> VTTCue::setLine(double position)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-line
     // On setting, if the text track cue snap-to-lines flag is not set, and the new
     // value is negative or greater than 100, then throw an IndexSizeError exception.
-    if (!m_snapToLines && (position < 0 || position > 100)) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
+    if (!m_snapToLines && !(position >= 0 && position <= 100))
+        return Exception { INDEX_SIZE_ERR };
 
     // Otherwise, set the text track cue line position to the new value.
     if (m_linePosition == position)
-        return;
+        return { };
 
     willChange();
     m_linePosition = position;
     m_computedLinePosition = calculateComputedLinePosition();
     didChange();
+
+    return { };
 }
 
-void VTTCue::setPosition(double position, ExceptionCode& ec)
+ExceptionOr<void> VTTCue::setPosition(double position)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-position
     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError exception.
     // Otherwise, set the text track cue text position to the new value.
-    if (position < 0 || position > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-    
+    if (!(position >= 0 && position <= 100))
+        return Exception { INDEX_SIZE_ERR };
+
     // Otherwise, set the text track cue line position to the new value.
     if (m_textPosition == position)
-        return;
+        return { };
     
     willChange();
     m_textPosition = position;
     didChange();
+
+    return { };
 }
 
-void VTTCue::setSize(int size, ExceptionCode& ec)
+ExceptionOr<void> VTTCue::setSize(int size)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-size
     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError
     // exception. Otherwise, set the text track cue size to the new value.
-    if (size < 0 || size > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-    
+    if (!(size >= 0 && size <= 100))
+        return Exception { INDEX_SIZE_ERR };
+
     // Otherwise, set the text track cue line position to the new value.
     if (m_cueSize == size)
-        return;
+        return { };
     
     willChange();
     m_cueSize = size;
     didChange();
+
+    return { };
 }
 
 const String& VTTCue::align() const
@@ -438,7 +440,7 @@ const String& VTTCue::align() const
     }
 }
 
-void VTTCue::setAlign(const String& value, ExceptionCode& ec)
+ExceptionOr<void> VTTCue::setAlign(const String& value)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-align
     // On setting, the text track cue alignment must be set to the value given in the 
@@ -446,7 +448,7 @@ void VTTCue::setAlign(const String& value, ExceptionCode& ec)
     // match for the new value, if any. If none of the values match, then the user
     // agent must instead throw a SyntaxError exception.
     
-    CueAlignment alignment = m_cueAlignment;
+    CueAlignment alignment;
     if (value == startKeyword())
         alignment = Start;
     else if (value == middleKeyword())
@@ -458,14 +460,16 @@ void VTTCue::setAlign(const String& value, ExceptionCode& ec)
     else if (value == rightKeyword())
         alignment = Right;
     else
-        ec = SYNTAX_ERR;
+        return Exception { SYNTAX_ERR };
     
     if (alignment == m_cueAlignment)
-        return;
+        return { };
 
     willChange();
     m_cueAlignment = alignment;
     didChange();
+
+    return { };
 }
     
 void VTTCue::setText(const String& text)
@@ -786,9 +790,9 @@ void VTTCue::updateDisplayTree(const MediaTime& movieTime)
     m_cueHighlightBox->appendChild(*referenceTree);
 }
 
-VTTCueBox* VTTCue::getDisplayTree(const IntSize& videoSize, int fontSize)
+VTTCueBox& VTTCue::getDisplayTree(const IntSize& videoSize, int fontSize)
 {
-    RefPtr<VTTCueBox> displayTree = displayTreeInternal();
+    Ref<VTTCueBox> displayTree = displayTreeInternal();
     if (!m_displayTreeShouldChange || !track()->isRendered())
         return displayTree.get();
 
@@ -839,7 +843,7 @@ void VTTCue::removeDisplayTree()
 
     if (!hasDisplayTree())
         return;
-    displayTreeInternal()->remove(ASSERT_NO_EXCEPTION);
+    displayTreeInternal().remove(ASSERT_NO_EXCEPTION);
 }
 
 std::pair<double, double> VTTCue::getPositionCoordinates() const
@@ -1141,7 +1145,7 @@ void VTTCue::setFontSize(int fontSize, const IntSize&, bool important)
     LOG(Media, "TextTrackCue::setFontSize - setting cue font size to %i", fontSize);
 
     m_displayTreeShouldChange = true;
-    displayTreeInternal()->setInlineStyleProperty(CSSPropertyFontSize, fontSize, CSSPrimitiveValue::CSS_PX, important);
+    displayTreeInternal().setInlineStyleProperty(CSSPropertyFontSize, fontSize, CSSPrimitiveValue::CSS_PX, important);
 }
 
 VTTCue* toVTTCue(TextTrackCue* cue)
index 989f373..5aa061f 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2011, 2013 Google Inc.  All rights reserved.
- * Copyright (C) 2012-2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2011, 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2012-2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -29,8 +29,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef VTTCue_h
-#define VTTCue_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
@@ -90,22 +89,22 @@ public:
     virtual ~VTTCue();
 
     const String& vertical() const;
-    void setVertical(const String&, ExceptionCode&);
+    ExceptionOr<void> setVertical(const String&);
 
     bool snapToLines() const { return m_snapToLines; }
     void setSnapToLines(bool);
 
     double line() const { return m_linePosition; }
-    virtual void setLine(double, ExceptionCode&);
+    virtual ExceptionOr<void> setLine(double);
 
     double position() const { return m_textPosition; }
-    virtual void setPosition(double, ExceptionCode&);
+    virtual ExceptionOr<void> setPosition(double);
 
     int size() const { return m_cueSize; }
-    virtual void setSize(int, ExceptionCode&);
+    ExceptionOr<void> setSize(int);
 
     const String& align() const;
-    void setAlign(const String&, ExceptionCode&);
+    ExceptionOr<void> setAlign(const String&);
 
     const String& text() const { return m_content; }
     void setText(const String&);
@@ -123,8 +122,8 @@ public:
     void setIsActive(bool) override;
 
     bool hasDisplayTree() const { return m_displayTree; }
-    VTTCueBox* getDisplayTree(const IntSize& videoSize, int fontSize);
-    HTMLSpanElement* element() const { return m_cueHighlightBox.get(); }
+    VTTCueBox& getDisplayTree(const IntSize& videoSize, int fontSize);
+    HTMLSpanElement& element() const { return *m_cueHighlightBox; }
 
     void updateDisplayTree(const MediaTime&);
     void removeDisplayTree();
@@ -173,8 +172,8 @@ protected:
     VTTCue(ScriptExecutionContext&, const MediaTime& start, const MediaTime& end, const String& content);
     VTTCue(ScriptExecutionContext&, const WebVTTCueData&);
 
-    virtual PassRefPtr<VTTCueBox> createDisplayTree();
-    VTTCueBox* displayTreeInternal();
+    virtual Ref<VTTCueBox> createDisplayTree();
+    VTTCueBox& displayTreeInternal();
 
 private:
     void initialize(ScriptExecutionContext&);
@@ -230,4 +229,3 @@ const VTTCue* toVTTCue(const TextTrackCue*);
 } // namespace WebCore
 
 #endif
-#endif
index 50410b3..9a3b78a 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Google Inc.  All rights reserved.
+ * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -22,6 +22,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
+
 [
     Conditional=VIDEO_TRACK,
     Constructor(unrestricted double startTime, unrestricted double endTime, DOMString text),
     JSGenerateToJSObject,
     JSGenerateToNativeObject,
 ] interface VTTCue : TextTrackCue {
-    [SetterMayThrowLegacyException] attribute DOMString vertical;
+    [SetterMayThrowException] attribute DOMString vertical;
     attribute boolean snapToLines;
-    [SetterMayThrowLegacyException] attribute unrestricted double line;
-    [SetterMayThrowLegacyException] attribute unrestricted double position;
-    [SetterMayThrowLegacyException] attribute unrestricted double size;
-    [SetterMayThrowLegacyException] attribute DOMString align;
+    [SetterMayThrowException] attribute double line;
+    [SetterMayThrowException] attribute double position;
+    [SetterMayThrowException] attribute double size;
+    [SetterMayThrowException] attribute DOMString align;
     attribute DOMString text;
     DocumentFragment getCueAsHTML();
 
index 79096bb..53a06b9 100644 (file)
 
 namespace WebCore {
 
-// The following values default values are defined within the WebVTT Regions Spec.
+// The default values are defined within the WebVTT Regions Spec.
 // https://dvcs.w3.org/hg/text-tracks/raw-file/default/608toVTT/region.html
 
-// The region occupies by default 100% of the width of the video viewport.
-static const float defaultWidth = 100;
-
-// The region has, by default, 3 lines of text.
-static const long defaultHeightInLines = 3;
-
-// The region and viewport are anchored in the bottom left corner.
-static const float defaultAnchorPointX = 0;
-static const float defaultAnchorPointY = 100;
-
-// The region doesn't have scrolling text, by default.
-static const bool defaultScroll = false;
-
 // Default region line-height (vh units)
 static const float lineHeight = 5.33;
 
@@ -74,15 +61,6 @@ static const float scrollTime = 0.433;
 VTTRegion::VTTRegion(ScriptExecutionContext& context)
     : ContextDestructionObserver(&context)
     , m_id(emptyString())
-    , m_width(defaultWidth)
-    , m_heightInLines(defaultHeightInLines)
-    , m_regionAnchor(FloatPoint(defaultAnchorPointX, defaultAnchorPointY))
-    , m_viewportAnchor(FloatPoint(defaultAnchorPointX, defaultAnchorPointY))
-    , m_scroll(defaultScroll)
-    , m_cueContainer(nullptr)
-    , m_regionDisplayTree(nullptr)
-    , m_track(nullptr)
-    , m_currentTop(0)
     , m_scrollTimer(*this, &VTTRegion::scrollTimerFired)
 {
 }
@@ -101,122 +79,85 @@ void VTTRegion::setId(const String& id)
     m_id = id;
 }
 
-void VTTRegion::setWidth(double value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setWidth(double value)
 {
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
-    if (value < 0 || value > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (!(value >= 0 && value <= 100))
+        return Exception { INDEX_SIZE_ERR };
     m_width = value;
+    return { };
 }
 
-void VTTRegion::setHeight(long value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setHeight(int value)
 {
-    if (value < 0) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (value < 0)
+        return Exception { INDEX_SIZE_ERR };
     m_heightInLines = value;
+    return { };
 }
 
-void VTTRegion::setRegionAnchorX(double value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setRegionAnchorX(double value)
 {
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
-    if (value < 0 || value > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (!(value >= 0 && value <= 100))
+        return Exception { INDEX_SIZE_ERR };
     m_regionAnchor.setX(value);
+    return { };
 }
 
-void VTTRegion::setRegionAnchorY(double value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setRegionAnchorY(double value)
 {
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
-    if (value < 0 || value > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (!(value >= 0 && value <= 100))
+        return Exception { INDEX_SIZE_ERR };
     m_regionAnchor.setY(value);
+    return { };
 }
 
-void VTTRegion::setViewportAnchorX(double value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setViewportAnchorX(double value)
 {
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
-    if (value < 0 || value > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (!(value >= 0 && value <= 100))
+        return Exception { INDEX_SIZE_ERR };
     m_viewportAnchor.setX(value);
+    return { };
 }
 
-void VTTRegion::setViewportAnchorY(double value, ExceptionCode& ec)
+ExceptionOr<void> VTTRegion::setViewportAnchorY(double value)
 {
-    if (std::isinf(value) || std::isnan(value)) {
-        ec = TypeError;
-        return;
-    }
-
-    if (value < 0 || value > 100) {
-        ec = INDEX_SIZE_ERR;
-        return;
-    }
-
+    if (!(value >= 0 && value <= 100))
+        return Exception { INDEX_SIZE_ERR };
     m_viewportAnchor.setY(value);
+    return { };
 }
 
-const AtomicString& VTTRegion::scroll() const
+static const AtomicString& upKeyword()
 {
-    static NeverDestroyed<const AtomicString> upScrollValueKeyword("up", AtomicString::ConstructFromLiteral);
-
-    if (m_scroll)
-        return upScrollValueKeyword;
-
-    return emptyAtom;
+    static NeverDestroyed<const AtomicString> upKeyword("up", AtomicString::ConstructFromLiteral);
+    return upKeyword;
 }
 
-void VTTRegion::setScroll(const AtomicString& value, ExceptionCode& ec)
+const AtomicString& VTTRegion::scroll() const
 {
-    static NeverDestroyed<const AtomicString> upScrollValueKeyword("up", AtomicString::ConstructFromLiteral);
+    return m_scroll ? upKeyword() : emptyAtom;
+}
 
-    if (value != emptyString() && value != upScrollValueKeyword) {
-        ec = SYNTAX_ERR;
-        return;
+ExceptionOr<void> VTTRegion::setScroll(const AtomicString& value)
+{
+    if (value.isEmpty()) {
+        m_scroll = false;
+        return { };
     }
-
-    m_scroll = value == upScrollValueKeyword;
+    if (value == upKeyword()) {
+        m_scroll = true;
+        return { };
+    }
+    return Exception { SYNTAX_ERR };
 }
 
-void VTTRegion::updateParametersFromRegion(VTTRegion* region)
+void VTTRegion::updateParametersFromRegion(const VTTRegion& other)
 {
-    m_heightInLines = region->height();
-    m_width = region->width();
-
-    m_regionAnchor = FloatPoint(region->regionAnchorX(), region->regionAnchorY());
-    m_viewportAnchor = FloatPoint(region->viewportAnchorX(), region->viewportAnchorY());
-
-    setScroll(region->scroll(), ASSERT_NO_EXCEPTION);
+    m_heightInLines = other.m_heightInLines;
+    m_width = other.m_width;
+    m_regionAnchor = other.m_regionAnchor;
+    m_viewportAnchor = other.m_viewportAnchor;
+    m_scroll = other.m_scroll;
 }
 
 void VTTRegion::setRegionSettings(const String& inputString)
@@ -268,8 +209,6 @@ static inline bool parsedEntireRun(const VTTScanner& input, const VTTScanner::Ru
 
 void VTTRegion::parseSettingValue(RegionSetting setting, VTTScanner& input)
 {
-    static NeverDestroyed<const AtomicString> scrollUpValueKeyword("up", AtomicString::ConstructFromLiteral);
-
     VTTScanner::Run valueRun = input.collectUntil<isHTMLSpace<UChar>>();
 
     switch (setting) {
@@ -312,7 +251,7 @@ void VTTRegion::parseSettingValue(RegionSetting setting, VTTScanner& input)
         break;
     }
     case Scroll:
-        if (input.scanRun(valueRun, scrollUpValueKeyword.get()))
+        if (input.scanRun(valueRun, upKeyword()))
             m_scroll = true;
         else
             LOG(Media, "VTTRegion::parseSettingValue, invalid Scroll");
@@ -345,14 +284,14 @@ const AtomicString& VTTRegion::textTrackRegionShadowPseudoId()
     return trackRegionShadowPseudoId;
 }
 
-void VTTRegion::appendTextTrackCueBox(PassRefPtr<VTTCueBox> displayBox)
+void VTTRegion::appendTextTrackCueBox(Ref<VTTCueBox>&& displayBox)
 {
     ASSERT(m_cueContainer);
 
-    if (m_cueContainer->contains(displayBox.get()))
+    if (m_cueContainer->contains(displayBox.ptr()))
         return;
 
-    m_cueContainer->appendChild(*displayBox, ASSERT_NO_EXCEPTION);
+    m_cueContainer->appendChild(displayBox, ASSERT_NO_EXCEPTION);
     displayLastTextTrackCueBox();
 }
 
@@ -405,7 +344,7 @@ void VTTRegion::willRemoveTextTrackCueBox(VTTCueBox* box)
 HTMLDivElement& VTTRegion::getDisplayTree()
 {
     if (!m_regionDisplayTree) {
-        m_regionDisplayTree = HTMLDivElement::create(*ownerDocument());
+        m_regionDisplayTree = HTMLDivElement::create(downcast<Document>(*m_scriptExecutionContext));
         prepareRegionDisplayTree();
     }
 
@@ -447,7 +386,7 @@ void VTTRegion::prepareRegionDisplayTree()
 
     // The cue container is used to wrap the cues and it is the object which is
     // gradually scrolled out as multiple cues are appended to the region.
-    m_cueContainer = HTMLDivElement::create(*ownerDocument());
+    m_cueContainer = HTMLDivElement::create(downcast<Document>(*m_scriptExecutionContext));
     m_cueContainer->setInlineStyleProperty(CSSPropertyTop, 0.0f, CSSPrimitiveValue::CSS_PX);
 
     m_cueContainer->setPseudo(textTrackCueContainerShadowPseudoId());
index 02f9b20..99c3e81 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2013 Google Inc.  All rights reserved.
- * Copyright (C) 2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef VTTRegion_h
-#define VTTRegion_h
+#pragma once
 
 #if ENABLE(VIDEO_TRACK)
 
 #include "ContextDestructionObserver.h"
-#include "Document.h"
 #include "FloatPoint.h"
 #include "TextTrack.h"
-#include <wtf/RefCounted.h>
 
 namespace WebCore {
 
@@ -62,27 +59,27 @@ public:
     void setId(const String&);
 
     double width() const { return m_width; }
-    void setWidth(double, ExceptionCode&);
+    ExceptionOr<void> setWidth(double);
 
-    long height() const { return m_heightInLines; }
-    void setHeight(long, ExceptionCode&);
+    int height() const { return m_heightInLines; }
+    ExceptionOr<void> setHeight(int);
 
     double regionAnchorX() const { return m_regionAnchor.x(); }
-    void setRegionAnchorX(double, ExceptionCode&);
+    ExceptionOr<void> setRegionAnchorX(double);
 
     double regionAnchorY() const { return m_regionAnchor.y(); }
-    void setRegionAnchorY(double, ExceptionCode&);
+    ExceptionOr<void> setRegionAnchorY(double);
 
     double viewportAnchorX() const { return m_viewportAnchor.x(); }
-    void setViewportAnchorX(double, ExceptionCode&);
+    ExceptionOr<void> setViewportAnchorX(double);
 
     double viewportAnchorY() const { return m_viewportAnchor.y(); }
-    void setViewportAnchorY(double, ExceptionCode&);
+    ExceptionOr<void> setViewportAnchorY(double);
 
     const AtomicString& scroll() const;
-    void setScroll(const AtomicString&, ExceptionCode&);
+    ExceptionOr<void> setScroll(const AtomicString&);
 
-    void updateParametersFromRegion(VTTRegion*);
+    void updateParametersFromRegion(const VTTRegion&);
 
     const String& regionSettings() const { return m_settings; }
     void setRegionSettings(const String&);
@@ -91,15 +88,13 @@ public:
 
     HTMLDivElement& getDisplayTree();
     
-    void appendTextTrackCueBox(PassRefPtr<VTTCueBox>);
+    void appendTextTrackCueBox(Ref<VTTCueBox>&&);
     void displayLastTextTrackCueBox();
     void willRemoveTextTrackCueBox(VTTCueBox*);
 
 private:
     VTTRegion(ScriptExecutionContext&);
 
-    Document* ownerDocument() { return downcast<Document>(m_scriptExecutionContext); }
-
     void prepareRegionDisplayTree();
 
     // The timer is needed to continue processing when cue scrolling ended.
@@ -128,13 +123,13 @@ private:
     String m_id;
     String m_settings;
 
-    double m_width;
-    unsigned m_heightInLines;
+    double m_width { 100 };
+    unsigned m_heightInLines { 3 };
 
-    FloatPoint m_regionAnchor;
-    FloatPoint m_viewportAnchor;
+    FloatPoint m_regionAnchor { 0, 100 };
+    FloatPoint m_viewportAnchor { 0, 100 };
 
-    bool m_scroll;
+    bool m_scroll { false };
 
     // The cue container is the container that is scrolled up to obtain the
     // effect of scrolling cues when this is enabled for the regions.
@@ -145,10 +140,10 @@ private:
     // reference a destroyed TextTrack, as this member variable
     // is cleared in the TextTrack destructor and it is generally
     // set/reset within the addRegion and removeRegion methods.
-    TextTrack* m_track;
+    TextTrack* m_track { nullptr };
 
     // Keep track of the current numeric value of the css "top" property.
-    double m_currentTop;
+    double m_currentTop { 0 };
 
     // The timer is used to display the next cue line after the current one has
     // been displayed. It's main use is for scrolling regions and it triggers as
@@ -161,4 +156,3 @@ private:
 } // namespace WebCore
 
 #endif
-#endif
index 206d1c1..7a24bc2 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2013 Google Inc.  All rights reserved.
- * Copyright (C) 2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 
 [
     Conditional=VIDEO_TRACK,
-    JSGenerateToNativeObject,
     Constructor(),
-    ConstructorCallWith=ScriptExecutionContext
+    ConstructorCallWith=ScriptExecutionContext,
+    JSGenerateToNativeObject,
 ] interface VTTRegion {
     readonly attribute TextTrack track;
 
     attribute DOMString id;
-    [SetterMayThrowLegacyException] attribute unrestricted double width;
-    [SetterMayThrowLegacyException] attribute long height;
-    [SetterMayThrowLegacyException] attribute unrestricted double regionAnchorX;
-    [SetterMayThrowLegacyException] attribute unrestricted double regionAnchorY;
-    [SetterMayThrowLegacyException] attribute unrestricted double viewportAnchorX;
-    [SetterMayThrowLegacyException] attribute unrestricted double viewportAnchorY;
-    [SetterMayThrowLegacyException] attribute DOMString scroll;
+    [SetterMayThrowException] attribute double width;
+    [SetterMayThrowException] attribute long height;
+    [SetterMayThrowException] attribute double regionAnchorX;
+    [SetterMayThrowException] attribute double regionAnchorY;
+    [SetterMayThrowException] attribute double viewportAnchorX;
+    [SetterMayThrowException] attribute double viewportAnchorY;
+    [SetterMayThrowException] attribute DOMString scroll;
 };
-