1 files changed, 62 insertions, 33 deletions
diff --git a/Source/WebCore/html/HTMLTableCellElement.cpp b/Source/WebCore/html/HTMLTableCellElement.cpp
index ccfbf27bc..c096dcf6c 100644
--- a/Source/WebCore/html/HTMLTableCellElement.cpp
+++ b/Source/WebCore/html/HTMLTableCellElement.cpp
@@ -25,40 +25,48 @@
 #include "config.h"
 #include "HTMLTableCellElement.h"
 
-#include "Attribute.h"
 #include "CSSPropertyNames.h"
 #include "CSSValueKeywords.h"
 #include "HTMLNames.h"
+#include "HTMLParserIdioms.h"
 #include "HTMLTableElement.h"
 #include "RenderTableCell.h"
 
 namespace WebCore {
 
-// Clamp rowspan at 8k to match Firefox.
-static const int maxRowspan = 8190;
-
 using namespace HTMLNames;
 
-inline HTMLTableCellElement::HTMLTableCellElement(const QualifiedName& tagName, Document& document)
+Ref<HTMLTableCellElement> HTMLTableCellElement::create(const QualifiedName& tagName, Document& document)
+{
+    return adoptRef(*new HTMLTableCellElement(tagName, document));
+}
+
+HTMLTableCellElement::HTMLTableCellElement(const QualifiedName& tagName, Document& document)
     : HTMLTablePartElement(tagName, document)
 {
+    ASSERT(tagName == thTag || tagName == tdTag);
+}
+
+unsigned HTMLTableCellElement::colSpan() const
+{
+    return std::max(1u, colSpanForBindings());
 }
 
-PassRefPtr<HTMLTableCellElement> HTMLTableCellElement::create(const QualifiedName& tagName, Document& document)
+unsigned HTMLTableCellElement::colSpanForBindings() const
 {
-    return adoptRef(new HTMLTableCellElement(tagName, document));
+    return limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(colspanAttr), 1u);
 }
 
-int HTMLTableCellElement::colSpan() const
+unsigned HTMLTableCellElement::rowSpan() const
 {
-    const AtomicString& colSpanValue = fastGetAttribute(colspanAttr);
-    return std::max(1, colSpanValue.toInt());
+    static const unsigned maxRowspan = 8190;
+    // FIXME: a rowSpan equal to 0 should be allowed, and mean that the cell is to span all the remaining rows in the row group.
+    return std::max(1u, std::min(rowSpanForBindings(), maxRowspan));
 }
 
-int HTMLTableCellElement::rowSpan() const
+unsigned HTMLTableCellElement::rowSpanForBindings() const
 {
-    const AtomicString& rowSpanValue = fastGetAttribute(rowspanAttr);
-    return std::max(1, std::min(rowSpanValue.toInt(), maxRowspan));
+    return limitToOnlyHTMLNonNegative(attributeWithoutSynchronization(rowspanAttr), 1u);
 }
 
 int HTMLTableCellElement::cellIndex() const
@@ -105,16 +113,16 @@ void HTMLTableCellElement::collectStyleForPresentationAttribute(const QualifiedN
 void HTMLTableCellElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == rowspanAttr) {
-        if (renderer() && renderer()->isTableCell())
-            toRenderTableCell(renderer())->colSpanOrRowSpanChanged();
+        if (is<RenderTableCell>(renderer()))
+            downcast<RenderTableCell>(*renderer()).colSpanOrRowSpanChanged();
     } else if (name == colspanAttr) {
-        if (renderer() && renderer()->isTableCell())
-            toRenderTableCell(renderer())->colSpanOrRowSpanChanged();
+        if (is<RenderTableCell>(renderer()))
+            downcast<RenderTableCell>(*renderer()).colSpanOrRowSpanChanged();
     } else
         HTMLTablePartElement::parseAttribute(name, value);
 }
 
-const StyleProperties* HTMLTableCellElement::additionalPresentationAttributeStyle()
+const StyleProperties* HTMLTableCellElement::additionalPresentationAttributeStyle() const
 {
     if (HTMLTableElement* table = findParentTable())
         return table->additionalCellStyle();
@@ -128,53 +136,74 @@ bool HTMLTableCellElement::isURLAttribute(const Attribute& attribute) const
 
 String HTMLTableCellElement::abbr() const
 {
-    return fastGetAttribute(abbrAttr);
+    return attributeWithoutSynchronization(abbrAttr);
 }
 
 String HTMLTableCellElement::axis() const
 {
-    return fastGetAttribute(axisAttr);
+    return attributeWithoutSynchronization(axisAttr);
 }
 
-void HTMLTableCellElement::setColSpan(int n)
+void HTMLTableCellElement::setColSpanForBindings(unsigned n)
 {
-    setIntegralAttribute(colspanAttr, n);
+    setAttributeWithoutSynchronization(colspanAttr, AtomicString::number(limitToOnlyHTMLNonNegative(n, 1)));
 }
 
 String HTMLTableCellElement::headers() const
 {
-    return fastGetAttribute(headersAttr);
+    return attributeWithoutSynchronization(headersAttr);
+}
+
+void HTMLTableCellElement::setRowSpanForBindings(unsigned n)
+{
+    setAttributeWithoutSynchronization(rowspanAttr, AtomicString::number(limitToOnlyHTMLNonNegative(n, 1)));
 }
 
-void HTMLTableCellElement::setRowSpan(int n)
+const AtomicString& HTMLTableCellElement::scope() const
 {
-    setIntegralAttribute(rowspanAttr, n);
+    // https://html.spec.whatwg.org/multipage/tables.html#attr-th-scope
+    static NeverDestroyed<const AtomicString> row("row", AtomicString::ConstructFromLiteral);
+    static NeverDestroyed<const AtomicString> col("col", AtomicString::ConstructFromLiteral);
+    static NeverDestroyed<const AtomicString> rowgroup("rowgroup", AtomicString::ConstructFromLiteral);
+    static NeverDestroyed<const AtomicString> colgroup("colgroup", AtomicString::ConstructFromLiteral);
+
+    const AtomicString& value = attributeWithoutSynchronization(HTMLNames::scopeAttr);
+
+    if (equalIgnoringASCIICase(value, row))
+        return row;
+    if (equalIgnoringASCIICase(value, col))
+        return col;
+    if (equalIgnoringASCIICase(value, rowgroup))
+        return rowgroup;
+    if (equalIgnoringASCIICase(value, colgroup))
+        return colgroup;
+    return emptyAtom;
 }
 
-String HTMLTableCellElement::scope() const
+void HTMLTableCellElement::setScope(const AtomicString& scope)
 {
-    return fastGetAttribute(scopeAttr);
+    setAttributeWithoutSynchronization(scopeAttr, scope);
 }
 
 void HTMLTableCellElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const
 {
     HTMLTablePartElement::addSubresourceAttributeURLs(urls);
 
-    addSubresourceURL(urls, document().completeURL(getAttribute(backgroundAttr)));
+    addSubresourceURL(urls, document().completeURL(attributeWithoutSynchronization(backgroundAttr)));
 }
 
 HTMLTableCellElement* HTMLTableCellElement::cellAbove() const
 {
-    auto cellRenderer = renderer();
-    if (!cellRenderer || !cellRenderer->isTableCell())
+    auto* cellRenderer = renderer();
+    if (!is<RenderTableCell>(cellRenderer))
         return nullptr;
 
-    auto tableCellRenderer = toRenderTableCell(cellRenderer);
-    auto cellAboveRenderer = tableCellRenderer->table()->cellAbove(tableCellRenderer);
+    auto& tableCellRenderer = downcast<RenderTableCell>(*cellRenderer);
+    auto* cellAboveRenderer = tableCellRenderer.table()->cellAbove(&tableCellRenderer);
     if (!cellAboveRenderer)
         return nullptr;
 
-    return toHTMLTableCellElement(cellAboveRenderer->element());
+    return downcast<HTMLTableCellElement>(cellAboveRenderer->element());
 }
 
 } // namespace WebCore