Unreviewed, rolling out r92419.
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Aug 2011 22:42:30 +0000 (22:42 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Aug 2011 22:42:30 +0000 (22:42 +0000)
http://trac.webkit.org/changeset/92419
https://bugs.webkit.org/show_bug.cgi?id=65726

"committed partially to branch" (Requested by thorton on
#webkit).

Patch by Sheriff Bot <webkit.review.bot@gmail.com> on 2011-08-04

Source/WebCore:

* svg/SVGCircleElement.cpp:
(WebCore::SVGCircleElement::parseMappedAttribute):
* svg/SVGCursorElement.cpp:
(WebCore::SVGCursorElement::parseMappedAttribute):
* svg/SVGEllipseElement.cpp:
(WebCore::SVGEllipseElement::parseMappedAttribute):
* svg/SVGFilterElement.cpp:
(WebCore::SVGFilterElement::parseMappedAttribute):
* svg/SVGFilterPrimitiveStandardAttributes.cpp:
(WebCore::SVGFilterPrimitiveStandardAttributes::parseMappedAttribute):
* svg/SVGForeignObjectElement.cpp:
(WebCore::SVGForeignObjectElement::parseMappedAttribute):
* svg/SVGImageElement.cpp:
(WebCore::SVGImageElement::parseMappedAttribute):
* svg/SVGLineElement.cpp:
(WebCore::SVGLineElement::parseMappedAttribute):
* svg/SVGLinearGradientElement.cpp:
(WebCore::SVGLinearGradientElement::parseMappedAttribute):
* svg/SVGMarkerElement.cpp:
(WebCore::SVGMarkerElement::parseMappedAttribute):
* svg/SVGMaskElement.cpp:
(WebCore::SVGMaskElement::parseMappedAttribute):
* svg/SVGPatternElement.cpp:
(WebCore::SVGPatternElement::parseMappedAttribute):
* svg/SVGRadialGradientElement.cpp:
(WebCore::SVGRadialGradientElement::parseMappedAttribute):
* svg/SVGRectElement.cpp:
(WebCore::SVGRectElement::parseMappedAttribute):
* svg/SVGSVGElement.cpp:
(WebCore::SVGSVGElement::parseMappedAttribute):
* svg/SVGTextContentElement.cpp:
(WebCore::SVGTextContentElement::parseMappedAttribute):
* svg/SVGTextPathElement.cpp:
(WebCore::SVGTextPathElement::parseMappedAttribute):
* svg/SVGUseElement.cpp:
(WebCore::SVGUseElement::parseMappedAttribute):

LayoutTests:

* platform/chromium-win/svg/hixie/error/013-expected.txt:
* platform/gtk/svg/hixie/error/001-expected.txt:
* platform/gtk/svg/hixie/error/007-expected.txt:
* platform/gtk/svg/hixie/error/013-expected.txt:
* platform/gtk/svg/hixie/error/015-expected.txt:
* platform/mac/svg/hixie/error/001-expected.txt:
* platform/mac/svg/hixie/error/007-expected.txt:
* platform/mac/svg/hixie/error/013-expected.txt:
* platform/mac/svg/hixie/error/015-expected.txt:
* platform/qt/svg/hixie/error/001-expected.txt:
* platform/qt/svg/hixie/error/007-expected.txt:
* platform/qt/svg/hixie/error/013-expected.txt:
* platform/qt/svg/hixie/error/015-expected.txt:
* svg/custom/invalid-length-units-expected.txt:
* svg/custom/svg-parse-overflow-1-expected.txt:
* svg/custom/svg-parse-overflow-2-expected.txt:
* svg/custom/svg-parse-overflow-3-expected.txt:
* svg/custom/svg-parse-overflow-4-expected.txt:
* svg/custom/svg-parse-overflow-5-expected.txt:

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

39 files changed:
LayoutTests/ChangeLog
LayoutTests/platform/chromium-win/svg/hixie/error/013-expected.txt
LayoutTests/platform/gtk/svg/hixie/error/001-expected.txt
LayoutTests/platform/gtk/svg/hixie/error/007-expected.txt
LayoutTests/platform/gtk/svg/hixie/error/013-expected.txt
LayoutTests/platform/gtk/svg/hixie/error/015-expected.txt
LayoutTests/platform/mac/svg/hixie/error/001-expected.txt
LayoutTests/platform/mac/svg/hixie/error/007-expected.txt
LayoutTests/platform/mac/svg/hixie/error/013-expected.txt
LayoutTests/platform/mac/svg/hixie/error/015-expected.txt
LayoutTests/platform/qt/svg/hixie/error/001-expected.txt
LayoutTests/platform/qt/svg/hixie/error/007-expected.txt
LayoutTests/platform/qt/svg/hixie/error/013-expected.txt
LayoutTests/platform/qt/svg/hixie/error/015-expected.txt
LayoutTests/svg/custom/invalid-length-units-expected.txt
LayoutTests/svg/custom/svg-parse-overflow-1-expected.txt
LayoutTests/svg/custom/svg-parse-overflow-2-expected.txt
LayoutTests/svg/custom/svg-parse-overflow-3-expected.txt
LayoutTests/svg/custom/svg-parse-overflow-4-expected.txt
LayoutTests/svg/custom/svg-parse-overflow-5-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/svg/SVGCircleElement.cpp
Source/WebCore/svg/SVGCursorElement.cpp
Source/WebCore/svg/SVGEllipseElement.cpp
Source/WebCore/svg/SVGFilterElement.cpp
Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.cpp
Source/WebCore/svg/SVGForeignObjectElement.cpp
Source/WebCore/svg/SVGImageElement.cpp
Source/WebCore/svg/SVGLineElement.cpp
Source/WebCore/svg/SVGLinearGradientElement.cpp
Source/WebCore/svg/SVGMarkerElement.cpp
Source/WebCore/svg/SVGMaskElement.cpp
Source/WebCore/svg/SVGPatternElement.cpp
Source/WebCore/svg/SVGRadialGradientElement.cpp
Source/WebCore/svg/SVGRectElement.cpp
Source/WebCore/svg/SVGSVGElement.cpp
Source/WebCore/svg/SVGTextContentElement.cpp
Source/WebCore/svg/SVGTextPathElement.cpp
Source/WebCore/svg/SVGUseElement.cpp

index cb6fa1b7f1c697367134f7811fabb9bc30887802..ccf2663ec457019534fca054fc2950f727b1000b 100644 (file)
@@ -1,3 +1,32 @@
+2011-08-04  Sheriff Bot  <webkit.review.bot@gmail.com>
+
+        Unreviewed, rolling out r92419.
+        http://trac.webkit.org/changeset/92419
+        https://bugs.webkit.org/show_bug.cgi?id=65726
+
+        "committed partially to branch" (Requested by thorton on
+        #webkit).
+
+        * platform/chromium-win/svg/hixie/error/013-expected.txt:
+        * platform/gtk/svg/hixie/error/001-expected.txt:
+        * platform/gtk/svg/hixie/error/007-expected.txt:
+        * platform/gtk/svg/hixie/error/013-expected.txt:
+        * platform/gtk/svg/hixie/error/015-expected.txt:
+        * platform/mac/svg/hixie/error/001-expected.txt:
+        * platform/mac/svg/hixie/error/007-expected.txt:
+        * platform/mac/svg/hixie/error/013-expected.txt:
+        * platform/mac/svg/hixie/error/015-expected.txt:
+        * platform/qt/svg/hixie/error/001-expected.txt:
+        * platform/qt/svg/hixie/error/007-expected.txt:
+        * platform/qt/svg/hixie/error/013-expected.txt:
+        * platform/qt/svg/hixie/error/015-expected.txt:
+        * svg/custom/invalid-length-units-expected.txt:
+        * svg/custom/svg-parse-overflow-1-expected.txt:
+        * svg/custom/svg-parse-overflow-2-expected.txt:
+        * svg/custom/svg-parse-overflow-3-expected.txt:
+        * svg/custom/svg-parse-overflow-4-expected.txt:
+        * svg/custom/svg-parse-overflow-5-expected.txt:
+
 2011-08-04  Tim Horton  <timothy_horton@apple.com>
 
         Reviewed by Nikolas Zimmerman.
index 4a1d283fa7b09dbe49aacb2debb54c84781ee52f..268df1b7589439104ac191d00522da114aeb309c 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 10: Error: Invalid negative value for <svg> attribute width="-100"
+CONSOLE MESSAGE: line 10: Error: A negative value for svg attribute <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x105
index bba68e2a35f2b4ad3ca58aa071965f165c45896d..db22044765286ddbec2b21ef2e027076e4d0e45e 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 3: Error: Invalid value for <circle> attribute r="r"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index bc3018c4b78c7465435e65b41115d35d399250a6..75c37e27e51b40bb651994be92f023b3efa8f5f8 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 4: Error: Invalid negative value for <rect> attribute width="-200"
+CONSOLE MESSAGE: line 4: Error: A negative value for rect <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index c55dffe1f63781dc575477b85e6095bf2fc1c05d..fdbc8083ae0fa814449c6220e7f103112d1b1015 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 10: Error: Invalid negative value for <svg> attribute width="-100"
+CONSOLE MESSAGE: line 10: Error: A negative value for svg attribute <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x102
index eff15fb05e4a07e3ca9cdc7c5fbb25f3cbacdcb1..324c3ed710cda1a4f2a52496a11546e055db7e9f 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 6: Error: Invalid value for <rect> attribute width=" 300"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 300x200
index bba68e2a35f2b4ad3ca58aa071965f165c45896d..db22044765286ddbec2b21ef2e027076e4d0e45e 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 3: Error: Invalid value for <circle> attribute r="r"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index bc3018c4b78c7465435e65b41115d35d399250a6..75c37e27e51b40bb651994be92f023b3efa8f5f8 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 4: Error: Invalid negative value for <rect> attribute width="-200"
+CONSOLE MESSAGE: line 4: Error: A negative value for rect <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index a7e474cf61c8929c73d9390b543f6294660606ea..15c36c738e41711fe92537ff677d58eb63645db7 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 10: Error: Invalid negative value for <svg> attribute width="-100"
+CONSOLE MESSAGE: line 10: Error: A negative value for svg attribute <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x100
index eff15fb05e4a07e3ca9cdc7c5fbb25f3cbacdcb1..324c3ed710cda1a4f2a52496a11546e055db7e9f 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 6: Error: Invalid value for <rect> attribute width=" 300"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 300x200
index bba68e2a35f2b4ad3ca58aa071965f165c45896d..db22044765286ddbec2b21ef2e027076e4d0e45e 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 3: Error: Invalid value for <circle> attribute r="r"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index bc3018c4b78c7465435e65b41115d35d399250a6..75c37e27e51b40bb651994be92f023b3efa8f5f8 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 4: Error: Invalid negative value for <rect> attribute width="-200"
+CONSOLE MESSAGE: line 4: Error: A negative value for rect <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x600
index 2bf5acbfba095a81dc4d19630527a759f4f2c3e6..012af1a725c33843621c758f6ef67775941470a4 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 10: Error: Invalid negative value for <svg> attribute width="-100"
+CONSOLE MESSAGE: line 10: Error: A negative value for svg attribute <width> is not allowed
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 800x110
index eff15fb05e4a07e3ca9cdc7c5fbb25f3cbacdcb1..324c3ed710cda1a4f2a52496a11546e055db7e9f 100644 (file)
@@ -1,4 +1,3 @@
-CONSOLE MESSAGE: line 6: Error: Invalid value for <rect> attribute width=" 300"
 layer at (0,0) size 800x600
   RenderView at (0,0) size 800x600
 layer at (0,0) size 300x200
index 45ce95aa6f15cbab6bc963e8c56e7b718c0a43a7..7512ae1629d2b375b20c8d356abe2a9c540c749a 100644 (file)
@@ -1,13 +1,3 @@
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x=" "
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="foo"
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10foo"
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="px"
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10px "
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10% "
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10 % "
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10 %"
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10 px "
-CONSOLE MESSAGE: line 9: Error: Invalid value for <rect> attribute x="10 px"
 Tests handling of invalid SVG length units.
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
index ff747f3494e83a23a3bb5553a9b4108fea190bf8..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
@@ -1,2 +1 @@
-CONSOLE MESSAGE: line 8: Error: Invalid value for <foreignObject> attribute y="105000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
 
index 7f4c75f3463cd389ab87d7a478a6b765a6e11788..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
@@ -1,2 +1 @@
-CONSOLE MESSAGE: line 8: Error: Invalid value for <rect> attribute height="-105000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
 
index 986809b044ed21c39f8ac1004c9e1d2e95b5826a..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
@@ -1,2 +1 @@
-CONSOLE MESSAGE: line 13: Error: Invalid value for <rect> attribute height="105000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
 
index e3bb83cb7fc946984fe3f7d3273bddee95b6127a..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
@@ -1,2 +1 @@
-CONSOLE MESSAGE: line 8: Error: Invalid value for <foreignObject> attribute y="105.0e50"
 
index a2c54fc937aae85d72831174395ade17dac2d230..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
@@ -1,2 +1 @@
-CONSOLE MESSAGE: line 8: Error: Invalid value for <foreignObject> attribute y="105.0e5000000000000000000000000000000000000000000000000000"
 
index 1f5a48a38c8656ab83dd510a49f46372f96232b8..b9f9d698e0bc97366dfd6d7d73b8c25d913183a9 100644 (file)
@@ -1,3 +1,49 @@
+2011-08-04  Sheriff Bot  <webkit.review.bot@gmail.com>
+
+        Unreviewed, rolling out r92419.
+        http://trac.webkit.org/changeset/92419
+        https://bugs.webkit.org/show_bug.cgi?id=65726
+
+        "committed partially to branch" (Requested by thorton on
+        #webkit).
+
+        * svg/SVGCircleElement.cpp:
+        (WebCore::SVGCircleElement::parseMappedAttribute):
+        * svg/SVGCursorElement.cpp:
+        (WebCore::SVGCursorElement::parseMappedAttribute):
+        * svg/SVGEllipseElement.cpp:
+        (WebCore::SVGEllipseElement::parseMappedAttribute):
+        * svg/SVGFilterElement.cpp:
+        (WebCore::SVGFilterElement::parseMappedAttribute):
+        * svg/SVGFilterPrimitiveStandardAttributes.cpp:
+        (WebCore::SVGFilterPrimitiveStandardAttributes::parseMappedAttribute):
+        * svg/SVGForeignObjectElement.cpp:
+        (WebCore::SVGForeignObjectElement::parseMappedAttribute):
+        * svg/SVGImageElement.cpp:
+        (WebCore::SVGImageElement::parseMappedAttribute):
+        * svg/SVGLineElement.cpp:
+        (WebCore::SVGLineElement::parseMappedAttribute):
+        * svg/SVGLinearGradientElement.cpp:
+        (WebCore::SVGLinearGradientElement::parseMappedAttribute):
+        * svg/SVGMarkerElement.cpp:
+        (WebCore::SVGMarkerElement::parseMappedAttribute):
+        * svg/SVGMaskElement.cpp:
+        (WebCore::SVGMaskElement::parseMappedAttribute):
+        * svg/SVGPatternElement.cpp:
+        (WebCore::SVGPatternElement::parseMappedAttribute):
+        * svg/SVGRadialGradientElement.cpp:
+        (WebCore::SVGRadialGradientElement::parseMappedAttribute):
+        * svg/SVGRectElement.cpp:
+        (WebCore::SVGRectElement::parseMappedAttribute):
+        * svg/SVGSVGElement.cpp:
+        (WebCore::SVGSVGElement::parseMappedAttribute):
+        * svg/SVGTextContentElement.cpp:
+        (WebCore::SVGTextContentElement::parseMappedAttribute):
+        * svg/SVGTextPathElement.cpp:
+        (WebCore::SVGTextPathElement::parseMappedAttribute):
+        * svg/SVGUseElement.cpp:
+        (WebCore::SVGUseElement::parseMappedAttribute):
+
 2011-08-04  Fady Samuel  <fsamuel@chromium.org>
 
         Background Does Not Scale Correctly with Page
index 2ae69b87fd63d65cd4ccc1308a02a0d7414a56e7..9411191a8fdb4a524479cd108eff5a47124c475d 100644 (file)
 #include "SVGCircleElement.h"
 
 #include "Attribute.h"
-#include "ExceptionCode.h"
 #include "FloatPoint.h"
 #include "RenderSVGPath.h"
 #include "RenderSVGResource.h"
 #include "SVGElementInstance.h"
-#include "SVGException.h"
 #include "SVGLength.h"
 #include "SVGNames.h"
 
@@ -81,23 +79,36 @@ bool SVGCircleElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGCircleElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::cxAttr)
-        setCxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::cyAttr)
-        setCyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::rAttr)
-        setRBaseValue(SVGLength::construct(LengthModeOther, attr->value(), parseError, ForbidNegativeLengths));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::cxAttr) {
+        setCxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::cyAttr) {
+        setCyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::rAttr) {
+        setRBaseValue(SVGLength(LengthModeOther, attr->value()));
+        if (rBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for circle <r> is not allowed");
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGCircleElement::svgAttributeChanged(const QualifiedName& attrName)
index 53df295838ef6d0b9eb07b632d9cef67c68e75a4..c083db44318d3937bf04168b37863fbf892bd78d 100644 (file)
@@ -80,21 +80,29 @@ bool SVGCursorElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGCursorElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-             || SVGURIReference::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
     
-    reportAttributeParsingError(parseError, attr);
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGCursorElement::addClient(SVGElement* element)
index cea066d11888615a63f00a381524d122806b4cf3..2cee32d1f81fc3759c0d90ff8901a374140c1133 100644 (file)
@@ -83,25 +83,43 @@ bool SVGEllipseElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGEllipseElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::cxAttr)
-        setCxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::cyAttr)
-        setCyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::rxAttr)
-        setRxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::ryAttr)
-        setRyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::cxAttr) {
+        setCxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::cyAttr) {
+        setCyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::rxAttr) {
+        setRxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        if (rxBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for ellipse <rx> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::ryAttr) {
+        setRyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        if (ryBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for ellipse <ry> is not allowed");
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGEllipseElement::svgAttributeChanged(const QualifiedName& attrName)
index d60a6a8e46d9760b12ce61d2caec07ee31884364..97160029cb6579e7c5a3a1bf81372f6b37ae66ba 100644 (file)
@@ -122,40 +122,63 @@ bool SVGFilterElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGFilterElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-    const AtomicString& value = attr->value();
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::filterUnitsAttr) {
+        return;
+    }
+
+    const AtomicString& value = attr->value();
+    if (attr->name() == SVGNames::filterUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
         if (propertyValue > 0)
             setFilterUnitsBaseValue(propertyValue);
-    } else if (attr->name() == SVGNames::primitiveUnitsAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::primitiveUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
         if (propertyValue > 0)
             setPrimitiveUnitsBaseValue(propertyValue);
-    } else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::filterResAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::filterResAttr) {
         float x, y;
         if (parseNumberOptionalNumber(value, x, y)) {
             setFilterResXBaseValue(x);
             setFilterResYBaseValue(y);
         }
-    } else if (SVGURIReference::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
 
-    reportAttributeParsingError(parseError, attr);
+    ASSERT_NOT_REACHED();
 }
 
 void SVGFilterElement::svgAttributeChanged(const QualifiedName& attrName)
index 1428ce4faf69a1665e660c817df00ff9c518ae7a..f4e4387756a392dc844d480ceb1d4b772536a6ee 100644 (file)
@@ -79,25 +79,38 @@ bool SVGFilterPrimitiveStandardAttributes::isSupportedAttribute(const QualifiedN
 
 void SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
+    if (!isSupportedAttribute(attr->name())) {
+        SVGStyledElement::parseMappedAttribute(attr);
+        return;
+    }
+
     const AtomicString& value = attr->value();
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
 
-    if (!isSupportedAttribute(attr->name()))
-        SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::resultAttr)
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::resultAttr) {
         setResultBaseValue(value);
-    else
-        ASSERT_NOT_REACHED();
+        return;
+    }
 
-    reportAttributeParsingError(parseError, attr);
+    ASSERT_NOT_REACHED();
 }
 
 bool SVGFilterPrimitiveStandardAttributes::setFilterEffectAttribute(FilterEffect*, const QualifiedName&)
index 7ba92ec459d783811bc687f0ac3f36e99d21a011..4ce6d97695eb13c8a39595a3ca8885d0463d7b4b 100644 (file)
@@ -86,26 +86,40 @@ bool SVGForeignObjectElement::isSupportedAttribute(const QualifiedName& attrName
 
 void SVGForeignObjectElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
+    if (!isSupportedAttribute(attr->name())) {
+        SVGStyledTransformableElement::parseMappedAttribute(attr);
+        return;
+    }
+
     const AtomicString& value = attr->value();
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
 
-    if (!isSupportedAttribute(attr->name()))
-        SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (SVGTests::parseMappedAttribute(attr)
-               || SVGLangSpace::parseMappedAttribute(attr)
-               || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGForeignObjectElement::svgAttributeChanged(const QualifiedName& attrName)
index 79fe128276e4535986976eedc3e2fab8978b73c6..96866d7c9a47cc9cc7d8b93ca507fe964fe57bf4 100644 (file)
@@ -93,30 +93,52 @@ bool SVGImageElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGImageElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::preserveAspectRatioAttr)
+        return;
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::preserveAspectRatioAttr) {
         SVGPreserveAspectRatio::parsePreserveAspectRatio(this, attr->value());
-    else if (attr->name() == SVGNames::widthAttr) {
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
         addCSSProperty(attr, CSSPropertyWidth, attr->value());
-    } else if (attr->name() == SVGNames::heightAttr) {
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
+        if (widthBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for image attribute <width> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
         addCSSProperty(attr, CSSPropertyHeight, attr->value());
-    } else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-             || SVGURIReference::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        if (heightBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for image attribute <height> is not allowed");
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGImageElement::svgAttributeChanged(const QualifiedName& attrName)
index c7ca11e1b320f51c29defb706c08cd5f9fb4a297..5707db60e0ea1fb898c677b926845b1c354dc366 100644 (file)
@@ -83,25 +83,39 @@ bool SVGLineElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGLineElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::x1Attr)
-        setX1BaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::y1Attr)
-        setY1BaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::x2Attr)
-        setX2BaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::y2Attr)
-        setY2BaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::x1Attr) {
+        setX1BaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::y1Attr) {
+        setY1BaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::x2Attr) {
+        setX2BaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::y2Attr) {
+        setY2BaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
index b1ac24dd437c6779aea3452812ab40160d3d4ba6..cf71af39eb2808ca2a5629fe5bee293f027a84ae 100644 (file)
@@ -85,22 +85,32 @@ bool SVGLinearGradientElement::isSupportedAttribute(const QualifiedName& attrNam
 
 void SVGLinearGradientElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGGradientElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::x1Attr)
-        setX1BaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::y1Attr)
-        setY1BaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::x2Attr)
-        setX2BaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::y2Attr)
-        setY2BaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::x1Attr) {
+        setX1BaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::y1Attr) {
+        setY1BaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::x2Attr) {
+        setX2BaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::y2Attr) {
+        setY2BaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGLinearGradientElement::svgAttributeChanged(const QualifiedName& attrName)
index 480e5bfcf0285f13e808d6c52990f12a64d20698..52bab8e86d7d92273b7e8212568197777b3b5690 100644 (file)
@@ -127,37 +127,57 @@ bool SVGMarkerElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGMarkerElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-    const AtomicString& value = attr->value();
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::markerUnitsAttr) {
+        return;
+    }
+
+    const AtomicString& value = attr->value();
+    if (attr->name() == SVGNames::markerUnitsAttr) {
         SVGMarkerUnitsType propertyValue = SVGPropertyTraits<SVGMarkerUnitsType>::fromString(value);
         if (propertyValue > 0)
             setMarkerUnitsBaseValue(propertyValue);
-    } else if (attr->name() == SVGNames::refXAttr)
-        setRefXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::refYAttr)
-        setRefYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::markerWidthAttr)
-        setMarkerWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
-    else if (attr->name() == SVGNames::markerHeightAttr)
-        setMarkerHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
-    else if (attr->name() == SVGNames::orientAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::refXAttr) {
+        setRefXBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::refYAttr) {
+        setRefYBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::markerWidthAttr) {
+        setMarkerWidthBaseValue(SVGLength(LengthModeWidth, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::markerHeightAttr) {
+        setMarkerHeightBaseValue(SVGLength(LengthModeHeight, value));
+        return;
+    }
+
+    if (attr->name() == SVGNames::orientAttr) {
         SVGAngle angle;
         SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(value, angle);
         if (orientType > 0)
             setOrientTypeBaseValue(orientType);
         if (orientType == SVGMarkerOrientAngle)
             setOrientAngleBaseValue(angle);
-    } else if (SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-             || SVGFitToViewBox::parseMappedAttribute(document(), attr)) {
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+    if (SVGFitToViewBox::parseMappedAttribute(document(), attr))
+        return;
 
-    reportAttributeParsingError(parseError, attr);
+    ASSERT_NOT_REACHED();
 }
 
 void SVGMarkerElement::svgAttributeChanged(const QualifiedName& attrName)
index 554a14305b833f36ee8c38ac4c51d2816b46bf30..5cc19e1e34aa38e777bc7f76e578d19bab0b3b27 100644 (file)
@@ -96,35 +96,53 @@ bool SVGMaskElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGMaskElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::maskUnitsAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::maskUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(attr->value());
         if (propertyValue > 0)
             setMaskUnitsBaseValue(propertyValue);
         return;
-    } else if (attr->name() == SVGNames::maskContentUnitsAttr) {
+    }
+
+    if (attr->name() == SVGNames::maskContentUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(attr->value());
         if (propertyValue > 0)
             setMaskContentUnitsBaseValue(propertyValue);
         return;
-    } else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGMaskElement::svgAttributeChanged(const QualifiedName& attrName)
index 9941004372eb55469edc3ddd50ffe6d00f4a3b37..5bfaffeaebbf9e73c0915dbcbadc48c6edec327b 100644 (file)
@@ -111,21 +111,26 @@ bool SVGPatternElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGPatternElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::patternUnitsAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::patternUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(attr->value());
         if (propertyValue > 0)
             setPatternUnitsBaseValue(propertyValue);
         return;
-    } else if (attr->name() == SVGNames::patternContentUnitsAttr) {
+    }
+
+    if (attr->name() == SVGNames::patternContentUnitsAttr) {
         SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(attr->value());
         if (propertyValue > 0)
             setPatternContentUnitsBaseValue(propertyValue);
         return;
-    } else if (attr->name() == SVGNames::patternTransformAttr) {
+    }
+
+    if (attr->name() == SVGNames::patternTransformAttr) {
         SVGTransformList newList;
         if (!SVGTransformable::parseTransformAttribute(newList, attr->value()))
             newList.clear();
@@ -133,23 +138,44 @@ void SVGPatternElement::parseMappedAttribute(Attribute* attr)
         detachAnimatedPatternTransformListWrappers(newList.size());
         setPatternTransformBaseValue(newList);
         return;
-    } else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
-    else if (SVGURIReference::parseMappedAttribute(attr)
-             || SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-             || SVGFitToViewBox::parseMappedAttribute(document(), attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        if (widthBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for pattern attribute <width> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        if (heightBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for pattern attribute <height> is not allowed");
+        return;
+    }
+
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+    if (SVGFitToViewBox::parseMappedAttribute(document(), attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGPatternElement::svgAttributeChanged(const QualifiedName& attrName)
index 0f86a6de282988cbb63f027511f46a6b40715e82..1c0c30b368d6d629ff9eec56ab646c762290c0a7 100644 (file)
@@ -89,24 +89,39 @@ bool SVGRadialGradientElement::isSupportedAttribute(const QualifiedName& attrNam
 
 void SVGRadialGradientElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGGradientElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::cxAttr)
-        setCxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::cyAttr)
-        setCyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::rAttr)
-        setRBaseValue(SVGLength::construct(LengthModeOther, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::fxAttr)
-        setFxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::fyAttr)
-        setFyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::cxAttr) {
+        setCxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::cyAttr) {
+        setCyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::rAttr) {
+        setRBaseValue(SVGLength(LengthModeOther, attr->value()));
+        if (rBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for radial gradient radius <r> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::fxAttr) {
+        setFxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::fyAttr) {
+        setFyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName)
index e84774d97175c80ba1c4e9473c64fe1028179ab0..00437da0845fd6e0011ae3cfa16f4a7c9844f892 100644 (file)
@@ -90,29 +90,57 @@ bool SVGRectElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGRectElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::rxAttr)
-        setRxBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::ryAttr)
-        setRyBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
-
-    reportAttributeParsingError(parseError, attr);
+        return;
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::rxAttr) {
+        setRxBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        if (rxBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for rect <rx> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::ryAttr) {
+        setRyBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        if (ryBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for rect <ry> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        if (widthBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for rect <width> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        if (heightBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for rect <height> is not allowed");
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 void SVGRectElement::svgAttributeChanged(const QualifiedName& attrName)
index a877d0806fa2a4412f1e3a137404b6ed7d34fc59..f3b0508ebc79a25d6a77be1ed4d492e68779a98c 100644 (file)
@@ -267,8 +267,6 @@ void SVGSVGElement::updateCurrentTranslate()
 
 void SVGSVGElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
     if (!nearestViewportElement()) {
         bool setListener = true;
 
@@ -293,24 +291,33 @@ void SVGSVGElement::parseMappedAttribute(Attribute* attr)
     else if (attr->name() == HTMLNames::onerrorAttr)
         document()->setWindowAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(document()->frame(), attr));
     else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
     else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
     else if (attr->name() == SVGNames::widthAttr) {
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
         addCSSProperty(attr, CSSPropertyWidth, attr->value());
+        if (widthBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for svg attribute <width> is not allowed");
     } else if (attr->name() == SVGNames::heightAttr) {
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
         addCSSProperty(attr, CSSPropertyHeight, attr->value());
-    } else if (SVGTests::parseMappedAttribute(attr)
-               || SVGLangSpace::parseMappedAttribute(attr)
-               || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-               || SVGFitToViewBox::parseMappedAttribute(document(), attr)
-               || SVGZoomAndPan::parseMappedAttribute(attr)) {
-    } else
-        SVGStyledLocatableElement::parseMappedAttribute(attr);
+        if (heightBaseValue().value(this) < 0.0)
+            document()->accessSVGExtensions()->reportError("A negative value for svg attribute <height> is not allowed");
+    } else {
+        if (SVGTests::parseMappedAttribute(attr))
+            return;
+        if (SVGLangSpace::parseMappedAttribute(attr))
+            return;
+        if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+            return;
+        if (SVGFitToViewBox::parseMappedAttribute(document(), attr))
+            return;
+        if (SVGZoomAndPan::parseMappedAttribute(attr))
+            return;
 
-    reportAttributeParsingError(parseError, attr);
+        SVGStyledLocatableElement::parseMappedAttribute(attr);
+    }
 }
 
 // This hack will not handle the case where we're setting a width/height
index a6483f4fa3b53fbee63ac8a0b96c9f10b724be54..854bc862594d6e94132aff244596f8655f658a15 100644 (file)
@@ -230,19 +230,29 @@ bool SVGTextContentElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGTextContentElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::lengthAdjustAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::lengthAdjustAttr) {
         SVGLengthAdjustType propertyValue = SVGPropertyTraits<SVGLengthAdjustType>::fromString(attr->value());
         if (propertyValue > 0)
             setLengthAdjustBaseValue(propertyValue);
-    } else if (attr->name() == SVGNames::textLengthAttr) {
-        m_textLength.value = SVGLength::construct(LengthModeOther, attr->value(), parseError, ForbidNegativeLengths);
-    } else if (SVGTests::parseMappedAttribute(attr)
-               || SVGExternalResourcesRequired::parseMappedAttribute(attr)) {
-    } else if (SVGLangSpace::parseMappedAttribute(attr)) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::textLengthAttr) {
+        m_textLength.value = SVGLength(LengthModeOther, attr->value());
+        if (m_textLength.value.value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for text attribute <textLength> is not allowed");
+        return;
+    }
+
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+
+    if (SVGLangSpace::parseMappedAttribute(attr)) {
         if (attr->name().matches(XMLNames::spaceAttr)) {
             DEFINE_STATIC_LOCAL(const AtomicString, preserveString, ("preserve"));
 
@@ -251,10 +261,13 @@ void SVGTextContentElement::parseMappedAttribute(Attribute* attr)
             else
                 addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValueNowrap);
         }
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
 
-    reportAttributeParsingError(parseError, attr);
+    ASSERT_NOT_REACHED();
 }
 
 void SVGTextContentElement::svgAttributeChanged(const QualifiedName& attrName)
index e2bb3cd7512f441e1d1d8ad966b74552861667d0..a92d606ed7b0db1cb3ccbd68c463d9758c8bd849 100644 (file)
@@ -74,26 +74,35 @@ bool SVGTextPathElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGTextPathElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
+    if (!isSupportedAttribute(attr->name())) {
+        SVGTextContentElement::parseMappedAttribute(attr);
+        return;
+    }
+
     const AtomicString& value = attr->value();
+    if (attr->name() == SVGNames::startOffsetAttr) {
+        setStartOffsetBaseValue(SVGLength(LengthModeOther, value));
+        return;
+    }
 
-    if (!isSupportedAttribute(attr->name()))
-        SVGTextContentElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::startOffsetAttr)
-        setStartOffsetBaseValue(SVGLength::construct(LengthModeOther, value, parseError));
-    else if (attr->name() == SVGNames::methodAttr) {
+    if (attr->name() == SVGNames::methodAttr) {
         SVGTextPathMethodType propertyValue = SVGPropertyTraits<SVGTextPathMethodType>::fromString(value);
         if (propertyValue > 0)
             setMethodBaseValue(propertyValue);
-    } else if (attr->name() == SVGNames::spacingAttr) {
+        return;
+    }
+
+    if (attr->name() == SVGNames::spacingAttr) {
         SVGTextPathSpacingType propertyValue = SVGPropertyTraits<SVGTextPathSpacingType>::fromString(value);
         if (propertyValue > 0)
             setSpacingBaseValue(propertyValue);
-    } else if (SVGURIReference::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
 
-    reportAttributeParsingError(parseError, attr);
+    ASSERT_NOT_REACHED();
 }
 
 void SVGTextPathElement::svgAttributeChanged(const QualifiedName& attrName)
index 145906575ba25ee570691894814311ae32d0c5dc..f3f28a634baad8cf39b6b53e21b6064485b580e5 100644 (file)
@@ -129,26 +129,45 @@ bool SVGUseElement::isSupportedAttribute(const QualifiedName& attrName)
 
 void SVGUseElement::parseMappedAttribute(Attribute* attr)
 {
-    SVGParsingError parseError = NoError;
-
-    if (!isSupportedAttribute(attr->name()))
+    if (!isSupportedAttribute(attr->name())) {
         SVGStyledTransformableElement::parseMappedAttribute(attr);
-    else if (attr->name() == SVGNames::xAttr)
-        setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
-    else if (attr->name() == SVGNames::yAttr)
-        setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
-    else if (attr->name() == SVGNames::widthAttr)
-        setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
-    else if (attr->name() == SVGNames::heightAttr)
-        setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
-    else if (SVGTests::parseMappedAttribute(attr)
-             || SVGLangSpace::parseMappedAttribute(attr)
-             || SVGExternalResourcesRequired::parseMappedAttribute(attr)
-             || SVGURIReference::parseMappedAttribute(attr)) {
-    } else
-        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    if (attr->name() == SVGNames::xAttr) {
+        setXBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::yAttr) {
+        setYBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        return;
+    }
+
+    if (attr->name() == SVGNames::widthAttr) {
+        setWidthBaseValue(SVGLength(LengthModeWidth, attr->value()));
+        if (widthBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for use attribute <width> is not allowed");
+        return;
+    }
+
+    if (attr->name() == SVGNames::heightAttr) {
+        setHeightBaseValue(SVGLength(LengthModeHeight, attr->value()));
+        if (heightBaseValue().value(this) < 0)
+            document()->accessSVGExtensions()->reportError("A negative value for use attribute <height> is not allowed");
+        return;
+    }
 
-    reportAttributeParsingError(parseError, attr);
+    if (SVGTests::parseMappedAttribute(attr))
+        return;
+    if (SVGLangSpace::parseMappedAttribute(attr))
+        return;
+    if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
+        return;
+    if (SVGURIReference::parseMappedAttribute(attr))
+        return;
+
+    ASSERT_NOT_REACHED();
 }
 
 static inline bool isWellFormedDocument(Document* document)