1/*
2 * Copyright (C) 1997 Martin Jones (mjones@kde.org)
3 *           (C) 1997 Torben Weis (weis@kde.org)
4 *           (C) 1998 Waldo Bastian (bastian@kde.org)
5 *           (C) 1999 Lars Knoll (knoll@kde.org)
6 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
7 * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2010, 2011 Apple Inc. All rights reserved.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Library General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * Library General Public License for more details.
18 *
19 * You should have received a copy of the GNU Library General Public License
20 * along with this library; see the file COPYING.LIB.  If not, write to
21 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
23 */
24
25#include "config.h"
26#include "core/html/HTMLTableElement.h"
27
28#include "bindings/core/v8/ExceptionState.h"
29#include "bindings/core/v8/ExceptionStatePlaceholder.h"
30#include "core/CSSPropertyNames.h"
31#include "core/CSSValueKeywords.h"
32#include "core/HTMLNames.h"
33#include "core/css/CSSImageValue.h"
34#include "core/css/CSSValuePool.h"
35#include "core/css/StylePropertySet.h"
36#include "core/dom/Attribute.h"
37#include "core/dom/ElementTraversal.h"
38#include "core/dom/ExceptionCode.h"
39#include "core/dom/NodeListsNodeData.h"
40#include "core/frame/UseCounter.h"
41#include "core/html/HTMLTableCaptionElement.h"
42#include "core/html/HTMLTableCellElement.h"
43#include "core/html/HTMLTableRowElement.h"
44#include "core/html/HTMLTableRowsCollection.h"
45#include "core/html/HTMLTableSectionElement.h"
46#include "core/html/parser/HTMLParserIdioms.h"
47#include "core/rendering/RenderTable.h"
48#include "platform/weborigin/Referrer.h"
49#include "wtf/StdLibExtras.h"
50
51namespace blink {
52
53using namespace HTMLNames;
54
55inline HTMLTableElement::HTMLTableElement(Document& document)
56    : HTMLElement(tableTag, document)
57    , m_borderAttr(false)
58    , m_borderColorAttr(false)
59    , m_frameAttr(false)
60    , m_rulesAttr(UnsetRules)
61    , m_padding(1)
62{
63}
64
65DEFINE_NODE_FACTORY(HTMLTableElement)
66
67HTMLTableCaptionElement* HTMLTableElement::caption() const
68{
69    return Traversal<HTMLTableCaptionElement>::firstChild(*this);
70}
71
72void HTMLTableElement::setCaption(PassRefPtrWillBeRawPtr<HTMLTableCaptionElement> newCaption, ExceptionState& exceptionState)
73{
74    deleteCaption();
75    insertBefore(newCaption, firstChild(), exceptionState);
76}
77
78HTMLTableSectionElement* HTMLTableElement::tHead() const
79{
80    return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(theadTag)));
81}
82
83void HTMLTableElement::setTHead(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newHead, ExceptionState& exceptionState)
84{
85    deleteTHead();
86
87    HTMLElement* child;
88    for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
89        if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
90            break;
91    }
92
93    insertBefore(newHead, child, exceptionState);
94}
95
96HTMLTableSectionElement* HTMLTableElement::tFoot() const
97{
98    return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(tfootTag)));
99}
100
101void HTMLTableElement::setTFoot(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newFoot, ExceptionState& exceptionState)
102{
103    deleteTFoot();
104
105    HTMLElement* child;
106    for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
107        if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
108            break;
109    }
110
111    insertBefore(newFoot, child, exceptionState);
112}
113
114PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTHead()
115{
116    if (HTMLTableSectionElement* existingHead = tHead())
117        return existingHead;
118    RefPtrWillBeRawPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
119    setTHead(head, IGNORE_EXCEPTION);
120    return head.release();
121}
122
123void HTMLTableElement::deleteTHead()
124{
125    removeChild(tHead(), IGNORE_EXCEPTION);
126}
127
128PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTFoot()
129{
130    if (HTMLTableSectionElement* existingFoot = tFoot())
131        return existingFoot;
132    RefPtrWillBeRawPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
133    setTFoot(foot, IGNORE_EXCEPTION);
134    return foot.release();
135}
136
137void HTMLTableElement::deleteTFoot()
138{
139    removeChild(tFoot(), IGNORE_EXCEPTION);
140}
141
142PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createTBody()
143{
144    RefPtrWillBeRawPtr<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
145    Node* referenceElement = lastBody() ? lastBody()->nextSibling() : 0;
146
147    insertBefore(body, referenceElement);
148    return body.release();
149}
150
151PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::createCaption()
152{
153    if (HTMLTableCaptionElement* existingCaption = caption())
154        return existingCaption;
155    RefPtrWillBeRawPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(document());
156    setCaption(caption, IGNORE_EXCEPTION);
157    return caption.release();
158}
159
160void HTMLTableElement::deleteCaption()
161{
162    removeChild(caption(), IGNORE_EXCEPTION);
163}
164
165HTMLTableSectionElement* HTMLTableElement::lastBody() const
166{
167    return toHTMLTableSectionElement(Traversal<HTMLElement>::lastChild(*this, HasHTMLTagName(tbodyTag)));
168}
169
170PassRefPtrWillBeRawPtr<HTMLElement> HTMLTableElement::insertRow(int index, ExceptionState& exceptionState)
171{
172    if (index < -1) {
173        exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
174        return nullptr;
175    }
176
177    RefPtrWillBeRawPtr<Node> protectFromMutationEvents(this);
178
179    RefPtrWillBeRawPtr<HTMLTableRowElement> lastRow = nullptr;
180    RefPtrWillBeRawPtr<HTMLTableRowElement> row = nullptr;
181    if (index == -1)
182        lastRow = HTMLTableRowsCollection::lastRow(*this);
183    else {
184        for (int i = 0; i <= index; ++i) {
185            row = HTMLTableRowsCollection::rowAfter(*this, lastRow.get());
186            if (!row) {
187                if (i != index) {
188                    exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than the number of rows in the table (" + String::number(i) + ").");
189                    return nullptr;
190                }
191                break;
192            }
193            lastRow = row;
194        }
195    }
196
197    RefPtrWillBeRawPtr<ContainerNode> parent;
198    if (lastRow)
199        parent = row ? row->parentNode() : lastRow->parentNode();
200    else {
201        parent = lastBody();
202        if (!parent) {
203            RefPtrWillBeRawPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
204            RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
205            newBody->appendChild(newRow, exceptionState);
206            appendChild(newBody.release(), exceptionState);
207            return newRow.release();
208        }
209    }
210
211    RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
212    parent->insertBefore(newRow, row.get(), exceptionState);
213    return newRow.release();
214}
215
216void HTMLTableElement::deleteRow(int index, ExceptionState& exceptionState)
217{
218    if (index < -1) {
219        exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
220        return;
221    }
222
223    HTMLTableRowElement* row = 0;
224    int i = 0;
225    if (index == -1)
226        row = HTMLTableRowsCollection::lastRow(*this);
227    else {
228        for (i = 0; i <= index; ++i) {
229            row = HTMLTableRowsCollection::rowAfter(*this, row);
230            if (!row)
231                break;
232        }
233    }
234    if (!row) {
235        exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than the number of rows in the table (" + String::number(i) + ").");
236        return;
237    }
238    row->remove(exceptionState);
239}
240
241void HTMLTableElement::setNeedsTableStyleRecalc() const
242{
243    Element* element = ElementTraversal::next(*this, this);
244    while (element) {
245        element->setNeedsStyleRecalc(LocalStyleChange);
246        if (isHTMLTableCellElement(*element))
247            element = ElementTraversal::nextSkippingChildren(*element, this);
248        else
249            element = ElementTraversal::next(*element, this);
250    }
251}
252
253static bool getBordersFromFrameAttributeValue(const AtomicString& value, bool& borderTop, bool& borderRight, bool& borderBottom, bool& borderLeft)
254{
255    borderTop = false;
256    borderRight = false;
257    borderBottom = false;
258    borderLeft = false;
259
260    if (equalIgnoringCase(value, "above"))
261        borderTop = true;
262    else if (equalIgnoringCase(value, "below"))
263        borderBottom = true;
264    else if (equalIgnoringCase(value, "hsides"))
265        borderTop = borderBottom = true;
266    else if (equalIgnoringCase(value, "vsides"))
267        borderLeft = borderRight = true;
268    else if (equalIgnoringCase(value, "lhs"))
269        borderLeft = true;
270    else if (equalIgnoringCase(value, "rhs"))
271        borderRight = true;
272    else if (equalIgnoringCase(value, "box") || equalIgnoringCase(value, "border"))
273        borderTop = borderBottom = borderLeft = borderRight = true;
274    else if (!equalIgnoringCase(value, "void"))
275        return false;
276    return true;
277}
278
279void HTMLTableElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
280{
281    if (name == widthAttr)
282        addHTMLLengthToStyle(style, CSSPropertyWidth, value);
283    else if (name == heightAttr)
284        addHTMLLengthToStyle(style, CSSPropertyHeight, value);
285    else if (name == borderAttr)
286        addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, parseBorderWidthAttribute(value), CSSPrimitiveValue::CSS_PX);
287    else if (name == bordercolorAttr) {
288        if (!value.isEmpty())
289            addHTMLColorToStyle(style, CSSPropertyBorderColor, value);
290    } else if (name == bgcolorAttr)
291        addHTMLColorToStyle(style, CSSPropertyBackgroundColor, value);
292    else if (name == backgroundAttr) {
293        String url = stripLeadingAndTrailingHTMLSpaces(value);
294        if (!url.isEmpty()) {
295            RefPtrWillBeRawPtr<CSSImageValue> imageValue = CSSImageValue::create(url, document().completeURL(url));
296            imageValue->setReferrer(Referrer(document().outgoingReferrer(), document().referrerPolicy()));
297            style->setProperty(CSSProperty(CSSPropertyBackgroundImage, imageValue.release()));
298        }
299    } else if (name == valignAttr) {
300        if (!value.isEmpty())
301            addPropertyToPresentationAttributeStyle(style, CSSPropertyVerticalAlign, value);
302    } else if (name == cellspacingAttr) {
303        if (!value.isEmpty())
304            addHTMLLengthToStyle(style, CSSPropertyBorderSpacing, value);
305    } else if (name == vspaceAttr) {
306        UseCounter::countDeprecation(document(), UseCounter::HTMLTableElementVspace);
307        addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
308        addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
309    } else if (name == hspaceAttr) {
310        UseCounter::countDeprecation(document(), UseCounter::HTMLTableElementHspace);
311        addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
312        addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
313    } else if (name == alignAttr) {
314        if (!value.isEmpty()) {
315            if (equalIgnoringCase(value, "center")) {
316                addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitMarginStart, CSSValueAuto);
317                addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitMarginEnd, CSSValueAuto);
318            } else
319                addPropertyToPresentationAttributeStyle(style, CSSPropertyFloat, value);
320        }
321    } else if (name == rulesAttr) {
322        // The presence of a valid rules attribute causes border collapsing to be enabled.
323        if (m_rulesAttr != UnsetRules)
324            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderCollapse, CSSValueCollapse);
325    } else if (name == frameAttr) {
326        bool borderTop;
327        bool borderRight;
328        bool borderBottom;
329        bool borderLeft;
330        if (getBordersFromFrameAttributeValue(value, borderTop, borderRight, borderBottom, borderLeft)) {
331            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, CSSValueThin);
332            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderTopStyle, borderTop ? CSSValueSolid : CSSValueHidden);
333            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderBottomStyle, borderBottom ? CSSValueSolid : CSSValueHidden);
334            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderLeftStyle, borderLeft ? CSSValueSolid : CSSValueHidden);
335            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderRightStyle, borderRight ? CSSValueSolid : CSSValueHidden);
336        }
337    } else
338        HTMLElement::collectStyleForPresentationAttribute(name, value, style);
339}
340
341bool HTMLTableElement::isPresentationAttribute(const QualifiedName& name) const
342{
343    if (name == widthAttr || name == heightAttr || name == bgcolorAttr || name == backgroundAttr || name == valignAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr || name == cellspacingAttr || name == borderAttr || name == bordercolorAttr || name == frameAttr || name == rulesAttr)
344        return true;
345    return HTMLElement::isPresentationAttribute(name);
346}
347
348void HTMLTableElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
349{
350    CellBorders bordersBefore = cellBorders();
351    unsigned short oldPadding = m_padding;
352
353    if (name == borderAttr)  {
354        // FIXME: This attribute is a mess.
355        m_borderAttr = parseBorderWidthAttribute(value);
356    } else if (name == bordercolorAttr) {
357        m_borderColorAttr = !value.isEmpty();
358    } else if (name == frameAttr) {
359        // FIXME: This attribute is a mess.
360        bool borderTop;
361        bool borderRight;
362        bool borderBottom;
363        bool borderLeft;
364        m_frameAttr = getBordersFromFrameAttributeValue(value, borderTop, borderRight, borderBottom, borderLeft);
365    } else if (name == rulesAttr) {
366        m_rulesAttr = UnsetRules;
367        if (equalIgnoringCase(value, "none"))
368            m_rulesAttr = NoneRules;
369        else if (equalIgnoringCase(value, "groups"))
370            m_rulesAttr = GroupsRules;
371        else if (equalIgnoringCase(value, "rows"))
372            m_rulesAttr = RowsRules;
373        else if (equalIgnoringCase(value, "cols"))
374            m_rulesAttr = ColsRules;
375        else if (equalIgnoringCase(value, "all"))
376            m_rulesAttr = AllRules;
377    } else if (name == cellpaddingAttr) {
378        if (!value.isEmpty())
379            m_padding = max(0, value.toInt());
380        else
381            m_padding = 1;
382    } else if (name == colsAttr) {
383        // ###
384    } else
385        HTMLElement::parseAttribute(name, value);
386
387    if (bordersBefore != cellBorders() || oldPadding != m_padding) {
388        m_sharedCellStyle = nullptr;
389        setNeedsTableStyleRecalc();
390    }
391}
392
393static PassRefPtrWillBeRawPtr<StylePropertySet> createBorderStyle(CSSValueID value)
394{
395    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
396    style->setProperty(CSSPropertyBorderTopStyle, value);
397    style->setProperty(CSSPropertyBorderBottomStyle, value);
398    style->setProperty(CSSPropertyBorderLeftStyle, value);
399    style->setProperty(CSSPropertyBorderRightStyle, value);
400    return style.release();
401}
402
403const StylePropertySet* HTMLTableElement::additionalPresentationAttributeStyle()
404{
405    if (m_frameAttr)
406        return 0;
407
408    if (!m_borderAttr && !m_borderColorAttr) {
409        // Setting the border to 'hidden' allows it to win over any border
410        // set on the table's cells during border-conflict resolution.
411        if (m_rulesAttr != UnsetRules) {
412            DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, solidBorderStyle, (createBorderStyle(CSSValueHidden)));
413            return solidBorderStyle;
414        }
415        return 0;
416    }
417
418    if (m_borderColorAttr) {
419        DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, solidBorderStyle, (createBorderStyle(CSSValueSolid)));
420        return solidBorderStyle;
421    }
422    DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, outsetBorderStyle, (createBorderStyle(CSSValueOutset)));
423    return outsetBorderStyle;
424}
425
426HTMLTableElement::CellBorders HTMLTableElement::cellBorders() const
427{
428    switch (m_rulesAttr) {
429        case NoneRules:
430        case GroupsRules:
431            return NoBorders;
432        case AllRules:
433            return SolidBorders;
434        case ColsRules:
435            return SolidBordersColsOnly;
436        case RowsRules:
437            return SolidBordersRowsOnly;
438        case UnsetRules:
439            if (!m_borderAttr)
440                return NoBorders;
441            if (m_borderColorAttr)
442                return SolidBorders;
443            return InsetBorders;
444    }
445    ASSERT_NOT_REACHED();
446    return NoBorders;
447}
448
449PassRefPtrWillBeRawPtr<StylePropertySet> HTMLTableElement::createSharedCellStyle()
450{
451    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
452
453    switch (cellBorders()) {
454    case SolidBordersColsOnly:
455        style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
456        style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
457        style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
458        style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
459        style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
460        break;
461    case SolidBordersRowsOnly:
462        style->setProperty(CSSPropertyBorderTopWidth, CSSValueThin);
463        style->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin);
464        style->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid);
465        style->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid);
466        style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
467        break;
468    case SolidBorders:
469        style->setProperty(CSSPropertyBorderWidth, cssValuePool().createValue(1, CSSPrimitiveValue::CSS_PX));
470        style->setProperty(CSSPropertyBorderStyle, cssValuePool().createIdentifierValue(CSSValueSolid));
471        style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
472        break;
473    case InsetBorders:
474        style->setProperty(CSSPropertyBorderWidth, cssValuePool().createValue(1, CSSPrimitiveValue::CSS_PX));
475        style->setProperty(CSSPropertyBorderStyle, cssValuePool().createIdentifierValue(CSSValueInset));
476        style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
477        break;
478    case NoBorders:
479        // If 'rules=none' then allow any borders set at cell level to take effect.
480        break;
481    }
482
483    if (m_padding)
484        style->setProperty(CSSPropertyPadding, cssValuePool().createValue(m_padding, CSSPrimitiveValue::CSS_PX));
485
486    return style.release();
487}
488
489const StylePropertySet* HTMLTableElement::additionalCellStyle()
490{
491    if (!m_sharedCellStyle)
492        m_sharedCellStyle = createSharedCellStyle();
493    return m_sharedCellStyle.get();
494}
495
496static PassRefPtrWillBeRawPtr<StylePropertySet> createGroupBorderStyle(int rows)
497{
498    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
499    if (rows) {
500        style->setProperty(CSSPropertyBorderTopWidth, CSSValueThin);
501        style->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin);
502        style->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid);
503        style->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid);
504    } else {
505        style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
506        style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
507        style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
508        style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
509    }
510    return style.release();
511}
512
513const StylePropertySet* HTMLTableElement::additionalGroupStyle(bool rows)
514{
515    if (m_rulesAttr != GroupsRules)
516        return 0;
517
518    if (rows) {
519        DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, rowBorderStyle, (createGroupBorderStyle(true)));
520        return rowBorderStyle;
521    }
522    DEFINE_STATIC_REF_WILL_BE_PERSISTENT(StylePropertySet, columnBorderStyle, (createGroupBorderStyle(false)));
523    return columnBorderStyle;
524}
525
526bool HTMLTableElement::isURLAttribute(const Attribute& attribute) const
527{
528    return attribute.name() == backgroundAttr || HTMLElement::isURLAttribute(attribute);
529}
530
531bool HTMLTableElement::hasLegalLinkAttribute(const QualifiedName& name) const
532{
533    return name == backgroundAttr || HTMLElement::hasLegalLinkAttribute(name);
534}
535
536const QualifiedName& HTMLTableElement::subResourceAttributeName() const
537{
538    return backgroundAttr;
539}
540
541PassRefPtrWillBeRawPtr<HTMLTableRowsCollection> HTMLTableElement::rows()
542{
543    return ensureCachedCollection<HTMLTableRowsCollection>(TableRows);
544}
545
546PassRefPtrWillBeRawPtr<HTMLCollection> HTMLTableElement::tBodies()
547{
548    return ensureCachedCollection<HTMLCollection>(TableTBodies);
549}
550
551const AtomicString& HTMLTableElement::rules() const
552{
553    return getAttribute(rulesAttr);
554}
555
556const AtomicString& HTMLTableElement::summary() const
557{
558    return getAttribute(summaryAttr);
559}
560
561void HTMLTableElement::trace(Visitor* visitor)
562{
563    visitor->trace(m_sharedCellStyle);
564    HTMLElement::trace(visitor);
565}
566
567}
568