http://trac.webkit.org/changeset/94421
https://bugs.webkit.org/show_bug.cgi?id=67496
Broke a number of tests on Chromium builders (including the
"cr-linux" EWS bot) (Requested by apavlov on #webkit).
Patch by Sheriff Bot <webkit.review.bot@gmail.com> on 2011-09-02
* accessibility/AXObjectCache.cpp:
(WebCore::nodeHasRole):
* accessibility/gtk/AccessibilityObjectWrapperAtk.cpp:
(webkit_accessible_get_name):
* dom/Document.cpp:
(WebCore::Document::buildAccessKeyMap):
(WebCore::Document::recalcStyleSelector):
* dom/Element.cpp:
(WebCore::Element::baseURI):
(WebCore::Element::formatForDebugger):
(WebCore::Element::spellcheckAttributeState):
* dom/NameNodeList.cpp:
(WebCore::NameNodeList::nodeMatches):
* editing/ApplyStyleCommand.cpp:
(WebCore::ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock):
* editing/SplitElementCommand.cpp:
(WebCore::SplitElementCommand::doUnapply):
* editing/markup.cpp:
(WebCore::shouldIncludeWrapperForFullySelectedRoot):
(WebCore::createMarkup):
* html/HTMLAnchorElement.cpp:
(WebCore::HTMLAnchorElement::draggable):
(WebCore::HTMLAnchorElement::href):
(WebCore::HTMLAnchorElement::name):
(WebCore::HTMLAnchorElement::target):
(WebCore::HTMLAnchorElement::sendPings):
(WebCore::HTMLAnchorElement::handleClick):
* html/HTMLAppletElement.cpp:
(WebCore::HTMLAppletElement::createRenderer):
* html/HTMLAreaElement.cpp:
(WebCore::HTMLAreaElement::target):
* html/HTMLBodyElement.cpp:
(WebCore::HTMLBodyElement::aLink):
(WebCore::HTMLBodyElement::bgColor):
(WebCore::HTMLBodyElement::link):
(WebCore::HTMLBodyElement::text):
(WebCore::HTMLBodyElement::vLink):
(WebCore::HTMLBodyElement::addSubresourceAttributeURLs):
* html/HTMLButtonElement.cpp:
(WebCore::HTMLButtonElement::value):
* html/HTMLCanvasElement.cpp:
(WebCore::HTMLCanvasElement::reset):
* html/HTMLCollection.cpp:
(WebCore::HTMLCollection::checkForNameMatch):
(WebCore::HTMLCollection::updateNameCache):
* html/HTMLDocument.cpp:
(WebCore::HTMLDocument::dir):
* html/HTMLElement.cpp:
(WebCore::HTMLElement::parseMappedAttribute):
(WebCore::HTMLElement::draggable):
(WebCore::HTMLElement::title):
(WebCore::setHasDirAutoFlagRecursively):
(WebCore::HTMLElement::directionalityIfhasDirAutoAttribute):
(WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged):
(WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildrenChanged):
* html/HTMLEmbedElement.cpp:
(WebCore::HTMLEmbedElement::updateWidget):
(WebCore::HTMLEmbedElement::insertedIntoDocument):
(WebCore::HTMLEmbedElement::addSubresourceAttributeURLs):
* html/HTMLFormCollection.cpp:
(WebCore::HTMLFormCollection::getNamedFormItem):
(WebCore::HTMLFormCollection::updateNameCache):
* html/HTMLFormControlElement.cpp:
(WebCore::HTMLFormControlElement::autofocus):
(WebCore::HTMLFormControlElement::updateVisibleValidationMessage):
* html/HTMLFormElement.cpp:
(WebCore::HTMLFormElement::name):
(WebCore::HTMLFormElement::action):
(WebCore::HTMLFormElement::method):
(WebCore::HTMLFormElement::target):
* html/HTMLFrameElement.cpp:
(WebCore::HTMLFrameElement::noResize):
* html/HTMLFrameElementBase.cpp:
(WebCore::HTMLFrameElementBase::setNameAndOpenURL):
(WebCore::HTMLFrameElementBase::location):
(WebCore::HTMLFrameElementBase::allowFullScreen):
* html/HTMLHtmlElement.cpp:
(WebCore::HTMLHtmlElement::insertedByParser):
* html/HTMLImageElement.cpp:
(WebCore::HTMLImageElement::altText):
(WebCore::HTMLImageElement::width):
(WebCore::HTMLImageElement::height):
(WebCore::HTMLImageElement::alt):
(WebCore::HTMLImageElement::draggable):
(WebCore::HTMLImageElement::src):
(WebCore::HTMLImageElement::addSubresourceAttributeURLs):
* html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::finishParsingChildren):
(WebCore::HTMLInputElement::altText):
(WebCore::HTMLInputElement::reset):
(WebCore::HTMLInputElement::searchEventsShouldBeDispatched):
(WebCore::HTMLInputElement::isSpeechEnabled):
* html/HTMLLabelElement.cpp:
(WebCore::HTMLLabelElement::control):
* html/HTMLLinkElement.cpp:
(WebCore::HTMLLinkElement::process):
(WebCore::HTMLLinkElement::href):
(WebCore::HTMLLinkElement::rel):
(WebCore::HTMLLinkElement::target):
(WebCore::HTMLLinkElement::type):
* html/HTMLMapElement.cpp:
(WebCore::HTMLMapElement::imageElement):
* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::attributeChanged):
(WebCore::HTMLMediaElement::insertedIntoDocument):
* html/HTMLMetaElement.cpp:
(WebCore::HTMLMetaElement::content):
(WebCore::HTMLMetaElement::httpEquiv):
(WebCore::HTMLMetaElement::name):
* html/HTMLMeterElement.cpp:
(WebCore::HTMLMeterElement::min):
(WebCore::HTMLMeterElement::max):
(WebCore::HTMLMeterElement::value):
(WebCore::HTMLMeterElement::low):
(WebCore::HTMLMeterElement::high):
(WebCore::HTMLMeterElement::optimum):
* html/HTMLNameCollection.cpp:
(WebCore::HTMLNameCollection::itemAfter):
* html/HTMLObjectElement.cpp:
(WebCore::HTMLObjectElement::updateWidget):
(WebCore::HTMLObjectElement::containsJavaApplet):
(WebCore::HTMLObjectElement::addSubresourceAttributeURLs):
* html/HTMLOptGroupElement.cpp:
(WebCore::HTMLOptGroupElement::groupLabelText):
* html/HTMLProgressElement.cpp:
(WebCore::HTMLProgressElement::max):
* html/HTMLScriptElement.cpp:
(WebCore::HTMLScriptElement::sourceAttributeValue):
(WebCore::HTMLScriptElement::charsetAttributeValue):
(WebCore::HTMLScriptElement::typeAttributeValue):
(WebCore::HTMLScriptElement::languageAttributeValue):
(WebCore::HTMLScriptElement::forAttributeValue):
(WebCore::HTMLScriptElement::eventAttributeValue):
* html/HTMLSourceElement.cpp:
(WebCore::HTMLSourceElement::media):
(WebCore::HTMLSourceElement::type):
* html/HTMLStyleElement.cpp:
(WebCore::HTMLStyleElement::media):
(WebCore::HTMLStyleElement::type):
* html/HTMLTableCellElement.cpp:
(WebCore::HTMLTableCellElement::abbr):
(WebCore::HTMLTableCellElement::axis):
(WebCore::HTMLTableCellElement::headers):
(WebCore::HTMLTableCellElement::scope):
(WebCore::HTMLTableCellElement::addSubresourceAttributeURLs):
* html/HTMLTableColElement.cpp:
(WebCore::HTMLTableColElement::width):
* html/HTMLTableElement.cpp:
(WebCore::HTMLTableElement::rules):
(WebCore::HTMLTableElement::summary):
(WebCore::HTMLTableElement::addSubresourceAttributeURLs):
* html/HTMLTableSectionElement.cpp:
(WebCore::HTMLTableSectionElement::align):
(WebCore::HTMLTableSectionElement::ch):
(WebCore::HTMLTableSectionElement::chOff):
(WebCore::HTMLTableSectionElement::vAlign):
* html/HTMLTextAreaElement.cpp:
(WebCore::HTMLTextAreaElement::maxLength):
* html/HTMLTextFormControlElement.cpp:
(WebCore::HTMLTextFormControlElement::strippedPlaceholder):
(WebCore::HTMLTextFormControlElement::isPlaceholderEmpty):
* html/HTMLTrackElement.cpp:
(WebCore::HTMLTrackElement::src):
(WebCore::HTMLTrackElement::kind):
(WebCore::HTMLTrackElement::srclang):
(WebCore::HTMLTrackElement::label):
(WebCore::HTMLTrackElement::isDefault):
(WebCore::HTMLTrackElement::load):
* html/HTMLVideoElement.cpp:
(WebCore::HTMLVideoElement::width):
(WebCore::HTMLVideoElement::height):
* html/StepRange.cpp:
(WebCore::StepRange::StepRange):
* html/shadow/TextControlInnerElements.cpp:
(WebCore::InputFieldSpeechButtonElement::startSpeechInput):
* inspector/InspectorPageAgent.cpp:
(WebCore::InspectorPageAgent::buildObjectForFrame):
* loader/FormSubmission.cpp:
(WebCore::FormSubmission::create):
* loader/ImageLoader.cpp:
(WebCore::ImageLoader::updateFromElement):
* page/Frame.cpp:
(WebCore::Frame::matchLabelsAgainstElement):
* page/PageSerializer.cpp:
(WebCore::PageSerializer::serializeFrame):
* page/mac/FrameMac.mm:
(WebCore::Frame::matchLabelsAgainstElement):
* platform/chromium/ClipboardChromium.cpp:
(WebCore::writeImageToDataObject):
* platform/chromium/PasteboardChromium.cpp:
(WebCore::Pasteboard::writeImage):
* platform/gtk/PasteboardGtk.cpp:
(WebCore::getURLForImageNode):
* platform/mac/HTMLConverter.mm:
(fileWrapperForElement):
* platform/win/ClipboardWin.cpp:
(WebCore::writeImageToDataObject):
(WebCore::ClipboardWin::declareAndWriteDragImage):
* rendering/HitTestResult.cpp:
(WebCore::HitTestResult::altDisplayString):
(WebCore::HitTestResult::absoluteImageURL):
(WebCore::HitTestResult::absoluteLinkURL):
* rendering/RenderDetails.cpp:
(WebCore::RenderDetails::isOpen):
* rendering/RenderMenuList.cpp:
(WebCore::RenderMenuList::itemAccessibilityText):
* rendering/RenderObject.cpp:
(WebCore::RenderObject::addPDFURLRect):
* rendering/RenderTableCell.cpp:
(WebCore::RenderTableCell::computePreferredLogicalWidths):
* rendering/RenderTextControlSingleLine.cpp:
(WebCore::RenderTextControlSingleLine::autosaveName):
* rendering/RenderVideo.cpp:
(WebCore::RenderVideo::calculateIntrinsicSize):
* rendering/mathml/RenderMathMLFenced.cpp:
(WebCore::RenderMathMLFenced::updateFromElement):
* rendering/mathml/RenderMathMLFraction.cpp:
(WebCore::RenderMathMLFraction::updateFromElement):
* rendering/mathml/RenderMathMLOperator.cpp:
(WebCore::RenderMathMLOperator::updateFromElement):
* svg/SVGFontData.cpp:
(WebCore::SVGFontData::applySVGGlyphSelection):
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@94427
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2011-09-02 Sheriff Bot <webkit.review.bot@gmail.com>
+
+ Unreviewed, rolling out r94421.
+ http://trac.webkit.org/changeset/94421
+ https://bugs.webkit.org/show_bug.cgi?id=67496
+
+ Broke a number of tests on Chromium builders (including the
+ "cr-linux" EWS bot) (Requested by apavlov on #webkit).
+
+ * accessibility/AXObjectCache.cpp:
+ (WebCore::nodeHasRole):
+ * accessibility/gtk/AccessibilityObjectWrapperAtk.cpp:
+ (webkit_accessible_get_name):
+ * dom/Document.cpp:
+ (WebCore::Document::buildAccessKeyMap):
+ (WebCore::Document::recalcStyleSelector):
+ * dom/Element.cpp:
+ (WebCore::Element::baseURI):
+ (WebCore::Element::formatForDebugger):
+ (WebCore::Element::spellcheckAttributeState):
+ * dom/NameNodeList.cpp:
+ (WebCore::NameNodeList::nodeMatches):
+ * editing/ApplyStyleCommand.cpp:
+ (WebCore::ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock):
+ * editing/SplitElementCommand.cpp:
+ (WebCore::SplitElementCommand::doUnapply):
+ * editing/markup.cpp:
+ (WebCore::shouldIncludeWrapperForFullySelectedRoot):
+ (WebCore::createMarkup):
+ * html/HTMLAnchorElement.cpp:
+ (WebCore::HTMLAnchorElement::draggable):
+ (WebCore::HTMLAnchorElement::href):
+ (WebCore::HTMLAnchorElement::name):
+ (WebCore::HTMLAnchorElement::target):
+ (WebCore::HTMLAnchorElement::sendPings):
+ (WebCore::HTMLAnchorElement::handleClick):
+ * html/HTMLAppletElement.cpp:
+ (WebCore::HTMLAppletElement::createRenderer):
+ * html/HTMLAreaElement.cpp:
+ (WebCore::HTMLAreaElement::target):
+ * html/HTMLBodyElement.cpp:
+ (WebCore::HTMLBodyElement::aLink):
+ (WebCore::HTMLBodyElement::bgColor):
+ (WebCore::HTMLBodyElement::link):
+ (WebCore::HTMLBodyElement::text):
+ (WebCore::HTMLBodyElement::vLink):
+ (WebCore::HTMLBodyElement::addSubresourceAttributeURLs):
+ * html/HTMLButtonElement.cpp:
+ (WebCore::HTMLButtonElement::value):
+ * html/HTMLCanvasElement.cpp:
+ (WebCore::HTMLCanvasElement::reset):
+ * html/HTMLCollection.cpp:
+ (WebCore::HTMLCollection::checkForNameMatch):
+ (WebCore::HTMLCollection::updateNameCache):
+ * html/HTMLDocument.cpp:
+ (WebCore::HTMLDocument::dir):
+ * html/HTMLElement.cpp:
+ (WebCore::HTMLElement::parseMappedAttribute):
+ (WebCore::HTMLElement::draggable):
+ (WebCore::HTMLElement::title):
+ (WebCore::setHasDirAutoFlagRecursively):
+ (WebCore::HTMLElement::directionalityIfhasDirAutoAttribute):
+ (WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged):
+ (WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildrenChanged):
+ * html/HTMLEmbedElement.cpp:
+ (WebCore::HTMLEmbedElement::updateWidget):
+ (WebCore::HTMLEmbedElement::insertedIntoDocument):
+ (WebCore::HTMLEmbedElement::addSubresourceAttributeURLs):
+ * html/HTMLFormCollection.cpp:
+ (WebCore::HTMLFormCollection::getNamedFormItem):
+ (WebCore::HTMLFormCollection::updateNameCache):
+ * html/HTMLFormControlElement.cpp:
+ (WebCore::HTMLFormControlElement::autofocus):
+ (WebCore::HTMLFormControlElement::updateVisibleValidationMessage):
+ * html/HTMLFormElement.cpp:
+ (WebCore::HTMLFormElement::name):
+ (WebCore::HTMLFormElement::action):
+ (WebCore::HTMLFormElement::method):
+ (WebCore::HTMLFormElement::target):
+ * html/HTMLFrameElement.cpp:
+ (WebCore::HTMLFrameElement::noResize):
+ * html/HTMLFrameElementBase.cpp:
+ (WebCore::HTMLFrameElementBase::setNameAndOpenURL):
+ (WebCore::HTMLFrameElementBase::location):
+ (WebCore::HTMLFrameElementBase::allowFullScreen):
+ * html/HTMLHtmlElement.cpp:
+ (WebCore::HTMLHtmlElement::insertedByParser):
+ * html/HTMLImageElement.cpp:
+ (WebCore::HTMLImageElement::altText):
+ (WebCore::HTMLImageElement::width):
+ (WebCore::HTMLImageElement::height):
+ (WebCore::HTMLImageElement::alt):
+ (WebCore::HTMLImageElement::draggable):
+ (WebCore::HTMLImageElement::src):
+ (WebCore::HTMLImageElement::addSubresourceAttributeURLs):
+ * html/HTMLInputElement.cpp:
+ (WebCore::HTMLInputElement::finishParsingChildren):
+ (WebCore::HTMLInputElement::altText):
+ (WebCore::HTMLInputElement::reset):
+ (WebCore::HTMLInputElement::searchEventsShouldBeDispatched):
+ (WebCore::HTMLInputElement::isSpeechEnabled):
+ * html/HTMLLabelElement.cpp:
+ (WebCore::HTMLLabelElement::control):
+ * html/HTMLLinkElement.cpp:
+ (WebCore::HTMLLinkElement::process):
+ (WebCore::HTMLLinkElement::href):
+ (WebCore::HTMLLinkElement::rel):
+ (WebCore::HTMLLinkElement::target):
+ (WebCore::HTMLLinkElement::type):
+ * html/HTMLMapElement.cpp:
+ (WebCore::HTMLMapElement::imageElement):
+ * html/HTMLMediaElement.cpp:
+ (WebCore::HTMLMediaElement::attributeChanged):
+ (WebCore::HTMLMediaElement::insertedIntoDocument):
+ * html/HTMLMetaElement.cpp:
+ (WebCore::HTMLMetaElement::content):
+ (WebCore::HTMLMetaElement::httpEquiv):
+ (WebCore::HTMLMetaElement::name):
+ * html/HTMLMeterElement.cpp:
+ (WebCore::HTMLMeterElement::min):
+ (WebCore::HTMLMeterElement::max):
+ (WebCore::HTMLMeterElement::value):
+ (WebCore::HTMLMeterElement::low):
+ (WebCore::HTMLMeterElement::high):
+ (WebCore::HTMLMeterElement::optimum):
+ * html/HTMLNameCollection.cpp:
+ (WebCore::HTMLNameCollection::itemAfter):
+ * html/HTMLObjectElement.cpp:
+ (WebCore::HTMLObjectElement::updateWidget):
+ (WebCore::HTMLObjectElement::containsJavaApplet):
+ (WebCore::HTMLObjectElement::addSubresourceAttributeURLs):
+ * html/HTMLOptGroupElement.cpp:
+ (WebCore::HTMLOptGroupElement::groupLabelText):
+ * html/HTMLProgressElement.cpp:
+ (WebCore::HTMLProgressElement::max):
+ * html/HTMLScriptElement.cpp:
+ (WebCore::HTMLScriptElement::sourceAttributeValue):
+ (WebCore::HTMLScriptElement::charsetAttributeValue):
+ (WebCore::HTMLScriptElement::typeAttributeValue):
+ (WebCore::HTMLScriptElement::languageAttributeValue):
+ (WebCore::HTMLScriptElement::forAttributeValue):
+ (WebCore::HTMLScriptElement::eventAttributeValue):
+ * html/HTMLSourceElement.cpp:
+ (WebCore::HTMLSourceElement::media):
+ (WebCore::HTMLSourceElement::type):
+ * html/HTMLStyleElement.cpp:
+ (WebCore::HTMLStyleElement::media):
+ (WebCore::HTMLStyleElement::type):
+ * html/HTMLTableCellElement.cpp:
+ (WebCore::HTMLTableCellElement::abbr):
+ (WebCore::HTMLTableCellElement::axis):
+ (WebCore::HTMLTableCellElement::headers):
+ (WebCore::HTMLTableCellElement::scope):
+ (WebCore::HTMLTableCellElement::addSubresourceAttributeURLs):
+ * html/HTMLTableColElement.cpp:
+ (WebCore::HTMLTableColElement::width):
+ * html/HTMLTableElement.cpp:
+ (WebCore::HTMLTableElement::rules):
+ (WebCore::HTMLTableElement::summary):
+ (WebCore::HTMLTableElement::addSubresourceAttributeURLs):
+ * html/HTMLTableSectionElement.cpp:
+ (WebCore::HTMLTableSectionElement::align):
+ (WebCore::HTMLTableSectionElement::ch):
+ (WebCore::HTMLTableSectionElement::chOff):
+ (WebCore::HTMLTableSectionElement::vAlign):
+ * html/HTMLTextAreaElement.cpp:
+ (WebCore::HTMLTextAreaElement::maxLength):
+ * html/HTMLTextFormControlElement.cpp:
+ (WebCore::HTMLTextFormControlElement::strippedPlaceholder):
+ (WebCore::HTMLTextFormControlElement::isPlaceholderEmpty):
+ * html/HTMLTrackElement.cpp:
+ (WebCore::HTMLTrackElement::src):
+ (WebCore::HTMLTrackElement::kind):
+ (WebCore::HTMLTrackElement::srclang):
+ (WebCore::HTMLTrackElement::label):
+ (WebCore::HTMLTrackElement::isDefault):
+ (WebCore::HTMLTrackElement::load):
+ * html/HTMLVideoElement.cpp:
+ (WebCore::HTMLVideoElement::width):
+ (WebCore::HTMLVideoElement::height):
+ * html/StepRange.cpp:
+ (WebCore::StepRange::StepRange):
+ * html/shadow/TextControlInnerElements.cpp:
+ (WebCore::InputFieldSpeechButtonElement::startSpeechInput):
+ * inspector/InspectorPageAgent.cpp:
+ (WebCore::InspectorPageAgent::buildObjectForFrame):
+ * loader/FormSubmission.cpp:
+ (WebCore::FormSubmission::create):
+ * loader/ImageLoader.cpp:
+ (WebCore::ImageLoader::updateFromElement):
+ * page/Frame.cpp:
+ (WebCore::Frame::matchLabelsAgainstElement):
+ * page/PageSerializer.cpp:
+ (WebCore::PageSerializer::serializeFrame):
+ * page/mac/FrameMac.mm:
+ (WebCore::Frame::matchLabelsAgainstElement):
+ * platform/chromium/ClipboardChromium.cpp:
+ (WebCore::writeImageToDataObject):
+ * platform/chromium/PasteboardChromium.cpp:
+ (WebCore::Pasteboard::writeImage):
+ * platform/gtk/PasteboardGtk.cpp:
+ (WebCore::getURLForImageNode):
+ * platform/mac/HTMLConverter.mm:
+ (fileWrapperForElement):
+ * platform/win/ClipboardWin.cpp:
+ (WebCore::writeImageToDataObject):
+ (WebCore::ClipboardWin::declareAndWriteDragImage):
+ * rendering/HitTestResult.cpp:
+ (WebCore::HitTestResult::altDisplayString):
+ (WebCore::HitTestResult::absoluteImageURL):
+ (WebCore::HitTestResult::absoluteLinkURL):
+ * rendering/RenderDetails.cpp:
+ (WebCore::RenderDetails::isOpen):
+ * rendering/RenderMenuList.cpp:
+ (WebCore::RenderMenuList::itemAccessibilityText):
+ * rendering/RenderObject.cpp:
+ (WebCore::RenderObject::addPDFURLRect):
+ * rendering/RenderTableCell.cpp:
+ (WebCore::RenderTableCell::computePreferredLogicalWidths):
+ * rendering/RenderTextControlSingleLine.cpp:
+ (WebCore::RenderTextControlSingleLine::autosaveName):
+ * rendering/RenderVideo.cpp:
+ (WebCore::RenderVideo::calculateIntrinsicSize):
+ * rendering/mathml/RenderMathMLFenced.cpp:
+ (WebCore::RenderMathMLFenced::updateFromElement):
+ * rendering/mathml/RenderMathMLFraction.cpp:
+ (WebCore::RenderMathMLFraction::updateFromElement):
+ * rendering/mathml/RenderMathMLOperator.cpp:
+ (WebCore::RenderMathMLOperator::updateFromElement):
+ * svg/SVGFontData.cpp:
+ (WebCore::SVGFontData::applySVGGlyphSelection):
+
2011-09-02 Alexey Proskuryakov <ap@apple.com>
REGRESSION (r94093): Private browsing doesn't start with a clean state on Snow Leopard
if (!node || !node->isElementNode())
return false;
- return equalIgnoringCase(static_cast<Element*>(node)->fastGetAttribute(roleAttr), role);
+ return equalIgnoringCase(static_cast<Element*>(node)->getAttribute(roleAttr), role);
}
static PassRefPtr<AccessibilityObject> createFromRenderer(RenderObject* renderer)
Node* node = coreObject->node();
if (node && node->isHTMLElement()) {
// Get the attribute rather than altText String so as not to fall back on title.
- String alt = toHTMLElement(node)->fastGetAttribute(HTMLNames::altAttr);
+ String alt = toHTMLElement(node)->getAttribute(HTMLNames::altAttr);
if (!alt.isEmpty())
return returnString(alt);
}
if (!n->isElementNode())
continue;
Element* element = static_cast<Element*>(n);
- const AtomicString& accessKey = element->fastGetAttribute(accesskeyAttr);
+ const AtomicString& accessKey = element->getAttribute(accesskeyAttr);
if (!accessKey.isEmpty())
m_elementsByAccessKey.set(accessKey.impl(), element);
buildAccessKeyMap(element->shadowRoot());
#endif
) {
Element* e = static_cast<Element*>(n);
- AtomicString title = e->fastGetAttribute(titleAttr);
+ AtomicString title = e->getAttribute(titleAttr);
bool enabledViaScript = false;
if (e->hasLocalName(linkTag)) {
// <LINK> element
if (linkElement->isLoading()) {
// it is loading but we should still decide which style sheet set to use
if (!enabledViaScript && !title.isEmpty() && m_preferredStylesheetSet.isEmpty()) {
- const AtomicString& rel = e->fastGetAttribute(relAttr);
+ const AtomicString& rel = e->getAttribute(relAttr);
if (!rel.contains("alternate")) {
m_preferredStylesheetSet = title;
m_selectedStylesheetSet = title;
// we are NOT an alternate sheet, then establish
// us as the preferred set. Otherwise, just ignore
// this sheet.
- AtomicString rel = e->fastGetAttribute(relAttr);
+ AtomicString rel = e->getAttribute(relAttr);
if (e->hasLocalName(styleTag) || !rel.contains("alternate"))
m_preferredStylesheetSet = m_selectedStylesheetSet = title;
}
KURL Element::baseURI() const
{
- const AtomicString& baseAttribute = fastGetAttribute(baseAttr);
+ const AtomicString& baseAttribute = getAttribute(baseAttr);
KURL base(KURL(), baseAttribute);
if (!base.protocol().isEmpty())
return base;
result += "id=";
result += s;
}
-
+
s = getAttribute(classAttr);
if (s.length() > 0) {
if (result.length() > 0)
SpellcheckAttributeState Element::spellcheckAttributeState() const
{
- const AtomicString& value = fastGetAttribute(spellcheckAttr);
+ const AtomicString& value = getAttribute(HTMLNames::spellcheckAttr);
if (value == nullAtom)
return SpellcheckAttributeDefault;
if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
bool NameNodeList::nodeMatches(Element* testNode) const
{
- return testNode->fastGetAttribute(nameAttr) == m_nodeName;
+ return testNode->getAttribute(nameAttr) == m_nodeName;
}
} // namespace WebCore
// and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
// For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
// otherwise it sets the property in the inline style declaration.
- if (element->fastHasAttribute(dirAttr)) {
+ if (element->hasAttribute(dirAttr)) {
// FIXME: If this is a BDO element, we should probably just remove it if it has no
// other attributes, like we (should) do with B and I elements.
removeNodeAttribute(element, dirAttr);
m_element2->insertBefore(children[i].get(), refChild.get(), ec);
// Recover the id attribute of the original element.
- if (m_element1->fastHasAttribute(HTMLNames::idAttr))
- m_element2->setAttribute(HTMLNames::idAttr, m_element1->fastGetAttribute(HTMLNames::idAttr));
+ if (m_element1->hasAttribute(HTMLNames::idAttr))
+ m_element2->setAttribute(HTMLNames::idAttr, m_element1->getAttribute(HTMLNames::idAttr));
m_element1->remove(ec);
}
static bool shouldIncludeWrapperForFullySelectedRoot(Node* fullySelectedRoot)
{
- if (fullySelectedRoot->isElementNode() && static_cast<Element*>(fullySelectedRoot)->fastHasAttribute(backgroundAttr))
+ if (fullySelectedRoot->isElementNode() && static_cast<Element*>(fullySelectedRoot)->hasAttribute(backgroundAttr))
return true;
RefPtr<EditingStyle> style = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
// Bring the background attribute over, but not as an attribute because a background attribute on a div
// appears to have no effect.
if ((!fullySelectedRootStyle || !fullySelectedRootStyle->style() || !fullySelectedRootStyle->style()->getPropertyCSSValue(CSSPropertyBackgroundImage))
- && static_cast<Element*>(fullySelectedRoot)->fastHasAttribute(backgroundAttr))
- fullySelectedRootStyle->style()->setProperty(CSSPropertyBackgroundImage, "url('" + static_cast<Element*>(fullySelectedRoot)->fastGetAttribute(backgroundAttr) + "')");
+ && static_cast<Element*>(fullySelectedRoot)->hasAttribute(backgroundAttr))
+ fullySelectedRootStyle->style()->setProperty(CSSPropertyBackgroundImage, "url('" + static_cast<Element*>(fullySelectedRoot)->getAttribute(backgroundAttr) + "')");
if (fullySelectedRootStyle->style()) {
// Reset the CSS properties to avoid an assertion error in addStyleMarkup().
bool HTMLAnchorElement::draggable() const
{
// Should be draggable if we have an href attribute.
- const AtomicString& value = fastGetAttribute(draggableAttr);
+ const AtomicString& value = getAttribute(draggableAttr);
if (equalIgnoringCase(value, "true"))
return true;
if (equalIgnoringCase(value, "false"))
return false;
- return fastHasAttribute(hrefAttr);
+ return hasAttribute(hrefAttr);
}
KURL HTMLAnchorElement::href() const
{
- return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(fastGetAttribute(hrefAttr)));
+ return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(hrefAttr)));
}
void HTMLAnchorElement::setHref(const AtomicString& value)
const AtomicString& HTMLAnchorElement::name() const
{
- return fastGetAttribute(nameAttr);
+ return getAttribute(nameAttr);
}
short HTMLAnchorElement::tabIndex() const
String HTMLAnchorElement::target() const
{
- return fastGetAttribute(targetAttr);
+ return getAttribute(targetAttr);
}
String HTMLAnchorElement::hash() const
void HTMLAnchorElement::sendPings(const KURL& destinationURL)
{
- if (!fastHasAttribute(pingAttr) || !document()->settings()->hyperlinkAuditingEnabled())
+ if (!hasAttribute(pingAttr) || !document()->settings()->hyperlinkAuditingEnabled())
return;
- SpaceSplitString pingURLs(fastGetAttribute(pingAttr), true);
+ SpaceSplitString pingURLs(getAttribute(pingAttr), true);
for (unsigned i = 0; i < pingURLs.size(); i++)
PingLoader::sendPing(document()->frame(), document()->completeURL(pingURLs[i]), destinationURL);
}
KURL kurl = document()->completeURL(url);
#if ENABLE(DOWNLOAD_ATTRIBUTE)
- if (fastHasAttribute(downloadAttr)) {
+ if (hasAttribute(downloadAttr)) {
ResourceRequest request(kurl);
if (!hasRel(RelationNoReferrer)) {
if (canEmbedJava()) {
HashMap<String, String> args;
- args.set("code", fastGetAttribute(codeAttr));
+ args.set("code", getAttribute(codeAttr));
- const AtomicString& codeBase = fastGetAttribute(codebaseAttr);
+ const AtomicString& codeBase = getAttribute(codebaseAttr);
if (!codeBase.isNull())
args.set("codeBase", codeBase);
- const AtomicString& name = document()->isHTMLDocument() ? fastGetAttribute(nameAttr) : getIdAttribute();
+ const AtomicString& name = document()->isHTMLDocument() ? getAttribute(nameAttr) : getIdAttribute();
if (!name.isNull())
args.set("name", name);
- const AtomicString& archive = fastGetAttribute(archiveAttr);
+ const AtomicString& archive = getAttribute(archiveAttr);
if (!archive.isNull())
args.set("archive", archive);
args.set("baseURL", document()->baseURL().string());
- const AtomicString& mayScript = fastGetAttribute(mayscriptAttr);
+ const AtomicString& mayScript = getAttribute(mayscriptAttr);
if (!mayScript.isNull())
args.set("mayScript", mayScript);
String HTMLAreaElement::target() const
{
- return fastGetAttribute(targetAttr);
+ return getAttribute(targetAttr);
}
}
String HTMLBodyElement::aLink() const
{
- return fastGetAttribute(alinkAttr);
+ return getAttribute(alinkAttr);
}
void HTMLBodyElement::setALink(const String& value)
String HTMLBodyElement::bgColor() const
{
- return fastGetAttribute(bgcolorAttr);
+ return getAttribute(bgcolorAttr);
}
void HTMLBodyElement::setBgColor(const String& value)
String HTMLBodyElement::link() const
{
- return fastGetAttribute(linkAttr);
+ return getAttribute(linkAttr);
}
void HTMLBodyElement::setLink(const String& value)
String HTMLBodyElement::text() const
{
- return fastGetAttribute(textAttr);
+ return getAttribute(textAttr);
}
void HTMLBodyElement::setText(const String& value)
String HTMLBodyElement::vLink() const
{
- return fastGetAttribute(vlinkAttr);
+ return getAttribute(vlinkAttr);
}
void HTMLBodyElement::setVLink(const String& value)
{
HTMLElement::addSubresourceAttributeURLs(urls);
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(backgroundAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(backgroundAttr)));
}
void HTMLBodyElement::didMoveToNewOwnerDocument()
String HTMLButtonElement::value() const
{
- return fastGetAttribute(valueAttr);
+ return getAttribute(valueAttr);
}
bool HTMLButtonElement::recalcWillValidate() const
bool ok;
bool hadImageBuffer = hasCreatedImageBuffer();
- int w = fastGetAttribute(widthAttr).toInt(&ok);
+ int w = getAttribute(widthAttr).toInt(&ok);
if (!ok || w < 0)
w = DefaultWidth;
- int h = fastGetAttribute(heightAttr).toInt(&ok);
+ int h = getAttribute(heightAttr).toInt(&ok);
if (!ok || h < 0)
h = DefaultHeight;
e->hasLocalName(selectTag)))
return false;
- return e->fastGetAttribute(nameAttr) == name && e->getIdAttribute() != name;
+ return e->getAttribute(nameAttr) == name && e->getIdAttribute() != name;
}
Node* HTMLCollection::namedItem(const AtomicString& name) const
continue;
HTMLElement* e = toHTMLElement(element);
const AtomicString& idAttrVal = e->getIdAttribute();
- const AtomicString& nameAttrVal = e->fastGetAttribute(nameAttr);
+ const AtomicString& nameAttrVal = e->getAttribute(nameAttr);
if (!idAttrVal.isEmpty()) {
// add to id cache
Vector<Element*>* idVector = m_info->idCache.get(idAttrVal.impl());
HTMLElement* b = body();
if (!b)
return String();
- return b->fastGetAttribute(dirAttr);
+ return b->getAttribute(dirAttr);
}
void HTMLDocument::setDir(const String& value)
} else if (attr->name() == hiddenAttr) {
addCSSProperty(attr, CSSPropertyDisplay, CSSValueNone);
} else if (attr->name() == tabindexAttr) {
- indexstring = fastGetAttribute(tabindexAttr);
+ indexstring = getAttribute(tabindexAttr);
int tabindex = 0;
if (!indexstring.length()) {
clearTabIndexExplicitly();
bool HTMLElement::draggable() const
{
- return equalIgnoringCase(fastGetAttribute(draggableAttr), "true");
+ return equalIgnoringCase(getAttribute(draggableAttr), "true");
}
void HTMLElement::setDraggable(bool value)
String HTMLElement::title() const
{
- return fastGetAttribute(titleAttr);
+ return getAttribute(titleAttr);
}
short HTMLElement::tabIndex() const
if (node->selfOrAncestorHasDirAutoAttribute() == flag)
return;
- if (node->isHTMLElement() && toElement(node)->fastHasAttribute(dirAttr)) {
+ if (node->isHTMLElement() && toElement(node)->hasAttribute(dirAttr)) {
if (node == lastNode)
return;
node = node->traverseNextSibling(firstNode);
TextDirection HTMLElement::directionalityIfhasDirAutoAttribute(bool& isAuto) const
{
- if (!(selfOrAncestorHasDirAutoAttribute() && equalIgnoringCase(fastGetAttribute(dirAttr), "auto"))) {
+ if (!(selfOrAncestorHasDirAutoAttribute() && equalIgnoringCase(getAttribute(dirAttr), "auto"))) {
isAuto = false;
return LTR;
}
if (renderer() && renderer()->style() && renderer()->style()->direction() != textDirection) {
Element* elementToAdjust = this;
for (; elementToAdjust; elementToAdjust = elementToAdjust->parentElement()) {
- if (elementToAdjust->fastHasAttribute(dirAttr)) {
+ if (elementToAdjust->hasAttribute(dirAttr)) {
elementToAdjust->setNeedsStyleRecalc();
return;
}
if ((!document() || document()->renderer()) && childCountDelta < 0) {
Node* node = beforeChange ? beforeChange->traverseNextSibling() : 0;
for (int counter = 0; node && counter < childCountDelta; counter++, node = node->traverseNextSibling()) {
- if (node->isElementNode() && toElement(node)->fastHasAttribute(dirAttr))
+ if (node->isElementNode() && toElement(node)->hasAttribute(dirAttr))
continue;
setHasDirAutoFlagRecursively(node, false);
return;
Node* oldMarkedNode = beforeChange ? beforeChange->traverseNextSibling() : 0;
- while (oldMarkedNode && oldMarkedNode->isHTMLElement() && toHTMLElement(oldMarkedNode)->fastHasAttribute(dirAttr))
+ while (oldMarkedNode && oldMarkedNode->isHTMLElement() && toHTMLElement(oldMarkedNode)->hasAttribute(dirAttr))
oldMarkedNode = oldMarkedNode->traverseNextSibling(this);
if (oldMarkedNode)
setHasDirAutoFlagRecursively(oldMarkedNode, false);
for (Element* elementToAdjust = this; elementToAdjust; elementToAdjust = elementToAdjust->parentElement()) {
- if (elementToAdjust->isHTMLElement() && elementToAdjust->fastHasAttribute(dirAttr)) {
+ if (elementToAdjust->isHTMLElement() && elementToAdjust->hasAttribute(dirAttr)) {
toHTMLElement(elementToAdjust)->calculateAndAdjustDirectionality();
return;
}
SubframeLoader* loader = document()->frame()->loader()->subframeLoader();
// FIXME: beforeLoad could have detached the renderer! Just like in the <object> case above.
- loader->requestObject(this, m_url, fastGetAttribute(nameAttr), m_serviceType, paramNames, paramValues);
+ loader->requestObject(this, m_url, getAttribute(nameAttr), m_serviceType, paramNames, paramValues);
}
bool HTMLEmbedElement::rendererIsNeeded(const NodeRenderingContext& context)
if (document()->isHTMLDocument())
static_cast<HTMLDocument*>(document())->addNamedItem(m_name);
- String width = fastGetAttribute(widthAttr);
- String height = fastGetAttribute(heightAttr);
+ String width = getAttribute(widthAttr);
+ String height = getAttribute(heightAttr);
if (!width.isEmpty() || !height.isEmpty()) {
Node* n = parentNode();
while (n && !n->hasTagName(objectTag))
{
HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(srcAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(srcAttr)));
}
}
for (unsigned i = 0; i < form->m_associatedElements.size(); ++i) {
FormAssociatedElement* associatedElement = form->m_associatedElements[i];
HTMLElement* element = toHTMLElement(associatedElement);
- if (associatedElement->isEnumeratable() && element->fastGetAttribute(attrName) == name) {
+ if (associatedElement->isEnumeratable() && element->getAttribute(attrName) == name) {
foundInputElements = true;
if (!duplicateNumber)
return element;
if (!foundInputElements) {
for (unsigned i = 0; i < form->m_imageElements.size(); ++i) {
HTMLImageElement* element = form->m_imageElements[i];
- if (element->fastGetAttribute(attrName) == name) {
+ if (element->getAttribute(attrName) == name) {
if (!duplicateNumber)
return element;
--duplicateNumber;
if (associatedElement->isEnumeratable()) {
HTMLElement* element = toHTMLElement(associatedElement);
const AtomicString& idAttrVal = element->getIdAttribute();
- const AtomicString& nameAttrVal = element->fastGetAttribute(nameAttr);
+ const AtomicString& nameAttrVal = element->getAttribute(nameAttr);
if (!idAttrVal.isEmpty()) {
// add to id cache
Vector<Element*>* idVector = info()->idCache.get(idAttrVal.impl());
for (unsigned i = 0; i < f->m_imageElements.size(); ++i) {
HTMLImageElement* element = f->m_imageElements[i];
const AtomicString& idAttrVal = element->getIdAttribute();
- const AtomicString& nameAttrVal = element->fastGetAttribute(nameAttr);
+ const AtomicString& nameAttrVal = element->getAttribute(nameAttr);
if (!idAttrVal.isEmpty() && !foundInputElements.contains(idAttrVal.impl())) {
// add to id cache
Vector<Element*>* idVector = info()->idCache.get(idAttrVal.impl());
bool HTMLFormControlElement::autofocus() const
{
- return fastHasAttribute(autofocusAttr);
+ return hasAttribute(autofocusAttr);
}
bool HTMLFormControlElement::required() const
// HTML5 specification doesn't ask UA to show the title attribute value
// with the validationMessage. However, this behavior is same as Opera
// and the specification describes such behavior as an example.
- const AtomicString& title = fastGetAttribute(titleAttr);
+ const AtomicString& title = getAttribute(titleAttr);
if (!message.isEmpty() && !title.isEmpty()) {
message.append('\n');
message.append(title);
String HTMLFormElement::name() const
{
- return fastGetAttribute(nameAttr);
+ return getAttribute(nameAttr);
}
bool HTMLFormElement::noValidate() const
// (Darin Adler) removed this, someone added it back, so I am leaving it in for now.
String HTMLFormElement::action() const
{
- return fastGetAttribute(actionAttr);
+ return getAttribute(actionAttr);
}
void HTMLFormElement::setAction(const String &value)
String HTMLFormElement::method() const
{
- return fastGetAttribute(methodAttr);
+ return getAttribute(methodAttr);
}
void HTMLFormElement::setMethod(const String &value)
String HTMLFormElement::target() const
{
- return fastGetAttribute(targetAttr);
+ return getAttribute(targetAttr);
}
bool HTMLFormElement::wasUserSubmitted() const
bool HTMLFrameElement::noResize() const
{
- return fastHasAttribute(noresizeAttr);
+ return hasAttribute(noresizeAttr);
}
void HTMLFrameElement::attach()
void HTMLFrameElementBase::setNameAndOpenURL()
{
- m_frameName = fastGetAttribute(nameAttr);
+ m_frameName = getAttribute(nameAttr);
if (m_frameName.isNull())
m_frameName = getIdAttribute();
openURL();
KURL HTMLFrameElementBase::location() const
{
- return document()->completeURL(fastGetAttribute(srcAttr));
+ return document()->completeURL(getAttribute(srcAttr));
}
void HTMLFrameElementBase::setLocation(const String& str)
#if ENABLE(FULLSCREEN_API)
bool HTMLFrameElementBase::allowFullScreen() const
{
- return fastHasAttribute(webkitallowfullscreenAttr);
+ return hasAttribute(webkitallowfullscreenAttr);
}
#endif
if (!documentLoader)
return;
- const AtomicString& manifest = fastGetAttribute(manifestAttr);
+ const AtomicString& manifest = getAttribute(manifestAttr);
if (manifest.isEmpty())
documentLoader->applicationCacheHost()->selectCacheWithoutManifest();
else
// lets figure out the alt text.. magic stuff
// http://www.w3.org/TR/1998/REC-html40-19980424/appendix/notes.html#altgen
// also heavily discussed by Hixie on bugzilla
- String alt = fastGetAttribute(altAttr);
+ String alt = getAttribute(altAttr);
// fall back to title attribute
if (alt.isNull())
- alt = fastGetAttribute(titleAttr);
+ alt = getAttribute(titleAttr);
return alt;
}
if (!renderer()) {
// check the attribute first for an explicit pixel value
bool ok;
- int width = fastGetAttribute(widthAttr).toInt(&ok);
+ int width = getAttribute(widthAttr).toInt(&ok);
if (ok)
return width;
if (!renderer()) {
// check the attribute first for an explicit pixel value
bool ok;
- int height = fastGetAttribute(heightAttr).toInt(&ok);
+ int height = getAttribute(heightAttr).toInt(&ok);
if (ok)
return height;
const AtomicString& HTMLImageElement::alt() const
{
- return fastGetAttribute(altAttr);
+ return getAttribute(altAttr);
}
bool HTMLImageElement::draggable() const
{
// Image elements are draggable by default.
- return !equalIgnoringCase(fastGetAttribute(draggableAttr), "false");
+ return !equalIgnoringCase(getAttribute(draggableAttr), "false");
}
void HTMLImageElement::setHeight(int value)
KURL HTMLImageElement::src() const
{
- return document()->completeURL(fastGetAttribute(srcAttr));
+ return document()->completeURL(getAttribute(srcAttr));
}
void HTMLImageElement::setSrc(const String& value)
addSubresourceURL(urls, src());
// FIXME: What about when the usemap attribute begins with "#"?
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(usemapAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(usemapAttr)));
}
void HTMLImageElement::willMoveToNewOwnerDocument()
m_parsingInProgress = false;
HTMLTextFormControlElement::finishParsingChildren();
if (!m_stateRestored) {
- bool checked = fastHasAttribute(checkedAttr);
+ bool checked = hasAttribute(checkedAttr);
if (checked)
setChecked(checked);
m_reflectsCheckedAttribute = true;
String alt = fastGetAttribute(altAttr);
// fall back to title attribute
if (alt.isNull())
- alt = fastGetAttribute(titleAttr);
+ alt = getAttribute(titleAttr);
if (alt.isNull())
- alt = fastGetAttribute(valueAttr);
+ alt = getAttribute(valueAttr);
if (alt.isEmpty())
alt = inputElementAltText();
return alt;
setValue(String());
setAutofilled(false);
- setChecked(fastHasAttribute(checkedAttr));
+ setChecked(hasAttribute(checkedAttr));
m_reflectsCheckedAttribute = true;
}
bool HTMLInputElement::searchEventsShouldBeDispatched() const
{
- return fastHasAttribute(incrementalAttr);
+ return hasAttribute(incrementalAttr);
}
void HTMLInputElement::setValueFromRenderer(const String& value)
bool HTMLInputElement::isSpeechEnabled() const
{
// FIXME: Add support for RANGE, EMAIL, URL, COLOR and DATE/TIME input types.
- return m_inputType->shouldRespectSpeechAttribute() && RuntimeEnabledFeatures::speechInputEnabled() && fastHasAttribute(webkitspeechAttr);
+ return m_inputType->shouldRespectSpeechAttribute() && RuntimeEnabledFeatures::speechInputEnabled() && hasAttribute(webkitspeechAttr);
}
#endif
HTMLFormControlElement* HTMLLabelElement::control()
{
- const AtomicString& controlId = fastGetAttribute(forAttr);
+ const AtomicString& controlId = getAttribute(forAttr);
if (controlId.isNull()) {
// Search the children and descendants of the label element for a form element.
// per http://dev.w3.org/html5/spec/Overview.html#the-label-element
if (m_disabledState != Disabled && (m_relAttribute.m_isStyleSheet || (acceptIfTypeContainsTextCSS && type.contains("text/css")))
&& document()->frame() && m_url.isValid()) {
- String charset = fastGetAttribute(charsetAttr);
+ String charset = getAttribute(charsetAttr);
if (charset.isEmpty() && document()->frame())
charset = document()->charset();
KURL HTMLLinkElement::href() const
{
- return document()->completeURL(fastGetAttribute(hrefAttr));
+ return document()->completeURL(getAttribute(hrefAttr));
}
String HTMLLinkElement::rel() const
{
- return fastGetAttribute(relAttr);
+ return getAttribute(relAttr);
}
String HTMLLinkElement::target() const
{
- return fastGetAttribute(targetAttr);
+ return getAttribute(targetAttr);
}
String HTMLLinkElement::type() const
{
- return fastGetAttribute(typeAttr);
+ return getAttribute(typeAttr);
}
void HTMLLinkElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
// The HTMLImageElement's useMap() value includes the '#' symbol at the beginning,
// which has to be stripped off.
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(curr);
- String useMapName = imageElement->fastGetAttribute(usemapAttr).string().substring(1);
+ String useMapName = imageElement->getAttribute(usemapAttr).string().substring(1);
if (equalIgnoringCase(useMapName, m_name))
return imageElement;
}
const QualifiedName& attrName = attr->name();
if (attrName == srcAttr) {
// Trigger a reload, as long as the 'src' attribute is present.
- if (!fastGetAttribute(srcAttr).isEmpty())
+ if (!getAttribute(srcAttr).isEmpty())
scheduleLoad();
}
else if (attrName == controlsAttr) {
{
LOG(Media, "HTMLMediaElement::removedFromDocument");
HTMLElement::insertedIntoDocument();
- if (!fastGetAttribute(srcAttr).isEmpty() && m_networkState == NETWORK_EMPTY)
+ if (!getAttribute(srcAttr).isEmpty() && m_networkState == NETWORK_EMPTY)
scheduleLoad();
}
String HTMLMetaElement::content() const
{
- return fastGetAttribute(contentAttr);
+ return getAttribute(contentAttr);
}
String HTMLMetaElement::httpEquiv() const
{
- return fastGetAttribute(http_equivAttr);
+ return getAttribute(http_equivAttr);
}
String HTMLMetaElement::name() const
{
- return fastGetAttribute(nameAttr);
+ return getAttribute(nameAttr);
}
}
double HTMLMeterElement::min() const
{
double min = 0;
- parseToDoubleForNumberType(fastGetAttribute(minAttr), &min);
+ parseToDoubleForNumberType(getAttribute(minAttr), &min);
return min;
}
double HTMLMeterElement::max() const
{
double max = std::max(1.0, min());
- parseToDoubleForNumberType(fastGetAttribute(maxAttr), &max);
+ parseToDoubleForNumberType(getAttribute(maxAttr), &max);
return std::max(max, min());
}
double HTMLMeterElement::value() const
{
double value = 0;
- parseToDoubleForNumberType(fastGetAttribute(valueAttr), &value);
+ parseToDoubleForNumberType(getAttribute(valueAttr), &value);
return std::min(std::max(value, min()), max());
}
double HTMLMeterElement::low() const
{
double low = min();
- parseToDoubleForNumberType(fastGetAttribute(lowAttr), &low);
+ parseToDoubleForNumberType(getAttribute(lowAttr), &low);
return std::min(std::max(low, min()), max());
}
double HTMLMeterElement::high() const
{
double high = max();
- parseToDoubleForNumberType(fastGetAttribute(highAttr), &high);
+ parseToDoubleForNumberType(getAttribute(highAttr), &high);
return std::min(std::max(high, low()), max());
}
double HTMLMeterElement::optimum() const
{
double optimum = (max() + min()) / 2;
- parseToDoubleForNumberType(fastGetAttribute(optimumAttr), &optimum);
+ parseToDoubleForNumberType(getAttribute(optimumAttr), &optimum);
return std::min(std::max(optimum, min()), max());
}
e->hasTagName(appletTag) ||
e->hasTagName(embedTag) ||
e->hasTagName(objectTag))
- if (e->fastGetAttribute(nameAttr) == m_name)
+ if (e->getAttribute(nameAttr) == m_name)
return e;
if (e->getIdAttribute() == m_name)
return e;
// applets and object by id, and images by id but only if they have
// a name attribute (this very strange rule matches IE)
if (e->hasTagName(formTag) || e->hasTagName(embedTag) || e->hasTagName(iframeTag)) {
- if (e->fastGetAttribute(nameAttr) == m_name)
+ if (e->getAttribute(nameAttr) == m_name)
return e;
} else if (e->hasTagName(appletTag)) {
- if (e->fastGetAttribute(nameAttr) == m_name || e->getIdAttribute() == m_name)
+ if (e->getAttribute(nameAttr) == m_name || e->getIdAttribute() == m_name)
return e;
} else if (e->hasTagName(objectTag)) {
- if ((e->fastGetAttribute(nameAttr) == m_name || e->getIdAttribute() == m_name)
+ if ((e->getAttribute(nameAttr) == m_name || e->getIdAttribute() == m_name)
&& static_cast<HTMLObjectElement*>(e)->isDocNamedItem())
return e;
} else if (e->hasTagName(imgTag)) {
- if (e->fastGetAttribute(nameAttr) == m_name || (e->getIdAttribute() == m_name && e->fastHasAttribute(nameAttr)))
+ if (e->getAttribute(nameAttr) == m_name || (e->getIdAttribute() == m_name && e->hasAttribute(nameAttr)))
return e;
}
break;
return;
SubframeLoader* loader = document()->frame()->loader()->subframeLoader();
- bool success = beforeLoadAllowedLoad && hasValidClassId() && loader->requestObject(this, url, fastGetAttribute(nameAttr), serviceType, paramNames, paramValues);
+ bool success = beforeLoadAllowedLoad && hasValidClassId() && loader->requestObject(this, url, getAttribute(nameAttr), serviceType, paramNames, paramValues);
if (!success && fallbackContent)
renderFallbackContent();
bool HTMLObjectElement::containsJavaApplet() const
{
- if (MIMETypeRegistry::isJavaAppletMIMEType(fastGetAttribute(typeAttr)))
+ if (MIMETypeRegistry::isJavaAppletMIMEType(getAttribute(typeAttr)))
return true;
for (Element* child = firstElementChild(); child; child = child->nextElementSibling()) {
if (child->hasTagName(paramTag)
- && equalIgnoringCase(child->fastGetAttribute(nameAttr), "type")
- && MIMETypeRegistry::isJavaAppletMIMEType(child->fastGetAttribute(valueAttr).string()))
+ && equalIgnoringCase(child->getAttribute(nameAttr), "type")
+ && MIMETypeRegistry::isJavaAppletMIMEType(child->getAttribute(valueAttr).string()))
return true;
if (child->hasTagName(objectTag)
&& static_cast<HTMLObjectElement*>(child)->containsJavaApplet())
{
HTMLPlugInImageElement::addSubresourceAttributeURLs(urls);
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(dataAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(dataAttr)));
// FIXME: Passing a string that starts with "#" to the completeURL function does
// not seem like it would work. The image element has similar but not identical code.
- const AtomicString& useMap = fastGetAttribute(usemapAttr);
+ const AtomicString& useMap = getAttribute(usemapAttr);
if (useMap.startsWith("#"))
addSubresourceURL(urls, document()->completeURL(useMap));
}
String HTMLOptGroupElement::groupLabelText() const
{
- String itemText = document()->displayStringModifiedByEncoding(fastGetAttribute(labelAttr));
+ String itemText = document()->displayStringModifiedByEncoding(getAttribute(labelAttr));
// In WinIE, leading and trailing whitespace is ignored in options and optgroups. We match this behavior.
itemText = itemText.stripWhiteSpace();
double HTMLProgressElement::max() const
{
double max;
- bool ok = parseToDoubleForNumberType(fastGetAttribute(maxAttr), &max);
+ bool ok = parseToDoubleForNumberType(getAttribute(maxAttr), &max);
if (!ok || max <= 0)
return 1;
return max;
String HTMLScriptElement::sourceAttributeValue() const
{
- return fastGetAttribute(srcAttr).string();
+ return getAttribute(srcAttr).string();
}
String HTMLScriptElement::charsetAttributeValue() const
{
- return fastGetAttribute(charsetAttr).string();
+ return getAttribute(charsetAttr).string();
}
String HTMLScriptElement::typeAttributeValue() const
{
- return fastGetAttribute(typeAttr).string();
+ return getAttribute(typeAttr).string();
}
String HTMLScriptElement::languageAttributeValue() const
{
- return fastGetAttribute(languageAttr).string();
+ return getAttribute(languageAttr).string();
}
String HTMLScriptElement::forAttributeValue() const
{
- return fastGetAttribute(forAttr).string();
+ return getAttribute(forAttr).string();
}
String HTMLScriptElement::eventAttributeValue() const
{
- return fastGetAttribute(eventAttr).string();
+ return getAttribute(eventAttr).string();
}
bool HTMLScriptElement::asyncAttributeValue() const
String HTMLSourceElement::media() const
{
- return fastGetAttribute(mediaAttr);
+ return getAttribute(mediaAttr);
}
void HTMLSourceElement::setMedia(const String& media)
String HTMLSourceElement::type() const
{
- return fastGetAttribute(typeAttr);
+ return getAttribute(typeAttr);
}
void HTMLSourceElement::setType(const String& type)
const AtomicString& HTMLStyleElement::media() const
{
- return fastGetAttribute(mediaAttr);
+ return getAttribute(mediaAttr);
}
const AtomicString& HTMLStyleElement::type() const
{
- return fastGetAttribute(typeAttr);
+ return getAttribute(typeAttr);
}
void HTMLStyleElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
String HTMLTableCellElement::abbr() const
{
- return fastGetAttribute(abbrAttr);
+ return getAttribute(abbrAttr);
}
String HTMLTableCellElement::axis() const
{
- return fastGetAttribute(axisAttr);
+ return getAttribute(axisAttr);
}
void HTMLTableCellElement::setColSpan(int n)
String HTMLTableCellElement::headers() const
{
- return fastGetAttribute(headersAttr);
+ return getAttribute(headersAttr);
}
void HTMLTableCellElement::setRowSpan(int n)
String HTMLTableCellElement::scope() const
{
- return fastGetAttribute(scopeAttr);
+ return getAttribute(scopeAttr);
}
void HTMLTableCellElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
{
HTMLTablePartElement::addSubresourceAttributeURLs(urls);
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(backgroundAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(backgroundAttr)));
}
HTMLTableCellElement* HTMLTableCellElement::cellAbove() const
String HTMLTableColElement::width() const
{
- return fastGetAttribute(widthAttr);
+ return getAttribute(widthAttr);
}
}
String HTMLTableElement::rules() const
{
- return fastGetAttribute(rulesAttr);
+ return getAttribute(rulesAttr);
}
String HTMLTableElement::summary() const
{
- return fastGetAttribute(summaryAttr);
+ return getAttribute(summaryAttr);
}
void HTMLTableElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
{
HTMLElement::addSubresourceAttributeURLs(urls);
- addSubresourceURL(urls, document()->completeURL(fastGetAttribute(backgroundAttr)));
+ addSubresourceURL(urls, document()->completeURL(getAttribute(backgroundAttr)));
}
}
String HTMLTableSectionElement::align() const
{
- return fastGetAttribute(alignAttr);
+ return getAttribute(alignAttr);
}
void HTMLTableSectionElement::setAlign(const String &value)
String HTMLTableSectionElement::ch() const
{
- return fastGetAttribute(charAttr);
+ return getAttribute(charAttr);
}
void HTMLTableSectionElement::setCh(const String &value)
String HTMLTableSectionElement::chOff() const
{
- return fastGetAttribute(charoffAttr);
+ return getAttribute(charoffAttr);
}
void HTMLTableSectionElement::setChOff(const String &value)
String HTMLTableSectionElement::vAlign() const
{
- return fastGetAttribute(valignAttr);
+ return getAttribute(valignAttr);
}
void HTMLTableSectionElement::setVAlign(const String &value)
int HTMLTextAreaElement::maxLength() const
{
bool ok;
- int value = fastGetAttribute(maxlengthAttr).string().toInt(&ok);
+ int value = getAttribute(maxlengthAttr).string().toInt(&ok);
return ok && value >= 0 ? value : -1;
}
{
// According to the HTML5 specification, we need to remove CR and LF from
// the attribute value.
- const AtomicString& attributeValue = fastGetAttribute(placeholderAttr);
+ const AtomicString& attributeValue = getAttribute(placeholderAttr);
if (!attributeValue.contains(newlineCharacter) && !attributeValue.contains(carriageReturn))
return attributeValue;
bool HTMLTextFormControlElement::isPlaceholderEmpty() const
{
- const AtomicString& attributeValue = fastGetAttribute(placeholderAttr);
+ const AtomicString& attributeValue = getAttribute(placeholderAttr);
return attributeValue.string().find(isNotLineBreak) == notFound;
}
KURL HTMLTrackElement::src() const
{
- return document()->completeURL(fastGetAttribute(srcAttr));
+ return document()->completeURL(getAttribute(srcAttr));
}
void HTMLTrackElement::setSrc(const String& url)
String HTMLTrackElement::kind() const
{
- return fastGetAttribute(kindAttr);
+ return getAttribute(kindAttr);
}
void HTMLTrackElement::setKind(const String& kind)
String HTMLTrackElement::srclang() const
{
- return fastGetAttribute(srclangAttr);
+ return getAttribute(srclangAttr);
}
void HTMLTrackElement::setSrclang(const String& srclang)
String HTMLTrackElement::label() const
{
- return fastGetAttribute(labelAttr);
+ return getAttribute(labelAttr);
}
void HTMLTrackElement::setLabel(const String& label)
bool HTMLTrackElement::isDefault() const
{
- return fastHasAttribute(defaultAttr);
+ return hasAttribute(defaultAttr);
}
void HTMLTrackElement::setIsDefault(bool isDefault)
{
m_track = LoadableTextTrack::create(kind(), label(), srclang(), isDefault());
- if (fastHasAttribute(srcAttr))
+ if (hasAttribute(srcAttr))
m_track->load(getNonEmptyURLAttribute(srcAttr), context);
}
unsigned HTMLVideoElement::width() const
{
bool ok;
- unsigned w = fastGetAttribute(widthAttr).string().toUInt(&ok);
+ unsigned w = getAttribute(widthAttr).string().toUInt(&ok);
return ok ? w : 0;
}
unsigned HTMLVideoElement::height() const
{
bool ok;
- unsigned h = fastGetAttribute(heightAttr).string().toUInt(&ok);
+ unsigned h = getAttribute(heightAttr).string().toUInt(&ok);
return ok ? h : 0;
}
StepRange::StepRange(const HTMLInputElement* element)
{
- const AtomicString& precisionValue = element->fastGetAttribute(precisionAttr);
- if (!precisionValue.isNull()) {
+ if (element->hasAttribute(precisionAttr)) {
step = 1.0;
- hasStep = !equalIgnoringCase(precisionValue.string(), "float");
+ hasStep = !equalIgnoringCase(element->getAttribute(precisionAttr), "float");
} else
hasStep = element->getAllowedValueStep(&step);
RefPtr<HTMLInputElement> input = static_cast<HTMLInputElement*>(shadowAncestorNode());
AtomicString language = input->computeInheritedLanguage();
- String grammar = input->fastGetAttribute(webkitgrammarAttr);
+ String grammar = input->getAttribute(webkitgrammarAttr);
IntRect rect = input->renderer()->absoluteBoundingBoxRect();
if (speechInput()->startRecognition(m_listenerId, rect, language, grammar, document()->securityOrigin()))
setState(Recording);
if (frame->tree()->parent())
frameObject->setString("parentId", frameId(frame->tree()->parent()));
if (frame->ownerElement()) {
- String name = frame->ownerElement()->fastGetAttribute(HTMLNames::nameAttr);
+ String name = frame->ownerElement()->getAttribute(HTMLNames::nameAttr);
if (name.isEmpty())
- name = frame->ownerElement()->fastGetAttribute(HTMLNames::idAttr);
+ name = frame->ownerElement()->getAttribute(HTMLNames::idAttr);
frameObject->setString("name", name);
}
frameObject->setString("url", frame->document()->url().string());
copiedAttributes.copyFrom(attributes);
if (submitButton) {
String attributeValue;
- if (!(attributeValue = submitButton->fastGetAttribute(formactionAttr)).isNull())
+ if (!(attributeValue = submitButton->getAttribute(formactionAttr)).isNull())
copiedAttributes.parseAction(attributeValue);
- if (!(attributeValue = submitButton->fastGetAttribute(formenctypeAttr)).isNull())
+ if (!(attributeValue = submitButton->getAttribute(formenctypeAttr)).isNull())
copiedAttributes.parseEncodingType(attributeValue);
- if (!(attributeValue = submitButton->fastGetAttribute(formmethodAttr)).isNull())
+ if (!(attributeValue = submitButton->getAttribute(formmethodAttr)).isNull())
copiedAttributes.parseMethodType(attributeValue);
- if (!(attributeValue = submitButton->fastGetAttribute(formtargetAttr)).isNull())
+ if (!(attributeValue = submitButton->getAttribute(formtargetAttr)).isNull())
copiedAttributes.setTarget(attributeValue);
}
if (!document->renderer())
return;
- AtomicString attr = m_element->fastGetAttribute(m_element->imageSourceAttributeName());
+ AtomicString attr = m_element->getAttribute(m_element->imageSourceAttributeName());
if (attr == m_failedLoadURL)
return;
// See 7538330 for one popular site that benefits from the id element check.
// FIXME: This code is mirrored in FrameMac.mm. It would be nice to make the Mac code call the platform-agnostic
// code, which would require converting the NSArray of NSStrings to a Vector of Strings somewhere along the way.
- String resultFromNameAttribute = matchLabelsAgainstString(labels, element->fastGetAttribute(nameAttr));
+ String resultFromNameAttribute = matchLabelsAgainstString(labels, element->getAttribute(nameAttr));
if (!resultFromNameAttribute.isEmpty())
return resultFromNameAttribute;
- return matchLabelsAgainstString(labels, element->fastGetAttribute(idAttr));
+ return matchLabelsAgainstString(labels, element->getAttribute(idAttr));
}
void Frame::setPrinting(bool printing, const FloatSize& pageSize, float maximumShrinkRatio, AdjustViewSizeOrNot shouldAdjustViewSize)
if (element->hasTagName(HTMLNames::imgTag)) {
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(element);
- KURL url = document->completeURL(imageElement->fastGetAttribute(HTMLNames::srcAttr));
+ KURL url = document->completeURL(imageElement->getAttribute(HTMLNames::srcAttr));
CachedImage* cachedImage = imageElement->cachedImage();
addImageToResources(cachedImage, url);
} else if (element->hasTagName(HTMLNames::linkTag)) {
HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(element);
StyleSheet* sheet = linkElement->sheet();
if (sheet && sheet->isCSSStyleSheet()) {
- KURL url = document->completeURL(linkElement->fastGetAttribute(HTMLNames::hrefAttr));
+ KURL url = document->completeURL(linkElement->getAttribute(HTMLNames::hrefAttr));
serializeCSSStyleSheet(static_cast<CSSStyleSheet*>(sheet), url);
ASSERT(m_resourceURLs.contains(url));
}
// See 7538330 for one popular site that benefits from the id element check.
// FIXME: This code is mirrored in Frame.cpp. It would be nice to make the Mac code call the platform-agnostic
// code, which would require converting the NSArray of NSStrings to a Vector of Strings somewhere along the way.
- String resultFromNameAttribute = matchLabelsAgainstString(labels, element->fastGetAttribute(nameAttr));
+ String resultFromNameAttribute = matchLabelsAgainstString(labels, element->getAttribute(nameAttr));
if (!resultFromNameAttribute.isEmpty())
return resultFromNameAttribute;
- return matchLabelsAgainstString(labels, element->fastGetAttribute(idAttr));
+ return matchLabelsAgainstString(labels, element->getAttribute(idAttr));
}
NSImage* Frame::imageFromRect(NSRect rect) const
if (filename.isEmpty())
filename = url.lastPathComponent();
if (filename.isEmpty())
- filename = element->fastGetAttribute(altAttr);
+ filename = element->getAttribute(altAttr);
else {
// Strip any existing extension. Assume that alt text is usually not a filename.
int extensionIndex = filename.reverseFind('.');
// link. This isn't useful to us, so get the actual image URL.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
- urlString = static_cast<Element*>(node)->fastGetAttribute(HTMLNames::srcAttr);
+ urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
- urlString = element->fastGetAttribute(element->imageSourceAttributeName());
+ urlString = element->getAttribute(element->imageSourceAttributeName());
}
KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
// FIXME: Later this code should be shared with Chromium somehow. Chances are all platforms want it.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
- urlString = static_cast<Element*>(node)->fastGetAttribute(HTMLNames::srcAttr);
+ urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
- urlString = element->fastGetAttribute(element->imageSourceAttributeName());
+ urlString = element->getAttribute(element->imageSourceAttributeName());
}
return urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
}
{
NSFileWrapper *wrapper = nil;
- const AtomicString& attr = element->fastGetAttribute(srcAttr);
+ const AtomicString& attr = element->getAttribute(srcAttr);
if (!attr.isEmpty()) {
NSURL *URL = element->document()->completeURL(attr);
if (DocumentLoader* loader = element->document()->loader())
if (!imageBuffer || !imageBuffer->size())
return;
- HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->fastGetAttribute(altAttr), cachedImage);
+ HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->getAttribute(altAttr), cachedImage);
if (!imageFileDescriptor)
return;
writeImageToDataObject(m_writableDataObject.get(), element, url);
- AtomicString imageURL = element->fastGetAttribute(srcAttr);
+ AtomicString imageURL = element->getAttribute(srcAttr);
if (imageURL.isEmpty())
return;
if (m_innerNonSharedNode->hasTagName(imgTag)) {
HTMLImageElement* image = static_cast<HTMLImageElement*>(m_innerNonSharedNode.get());
- return displayString(image->fastGetAttribute(altAttr), m_innerNonSharedNode.get());
+ return displayString(image->getAttribute(altAttr), m_innerNonSharedNode.get());
}
if (m_innerNonSharedNode->hasTagName(inputTag)) {
#endif
) {
Element* element = static_cast<Element*>(m_innerNonSharedNode.get());
- urlString = element->fastGetAttribute(element->imageSourceAttributeName());
+ urlString = element->getAttribute(element->imageSourceAttributeName());
} else
return KURL();
AtomicString urlString;
if (m_innerURLElement->hasTagName(aTag) || m_innerURLElement->hasTagName(areaTag) || m_innerURLElement->hasTagName(linkTag))
- urlString = m_innerURLElement->fastGetAttribute(hrefAttr);
+ urlString = m_innerURLElement->getAttribute(hrefAttr);
#if ENABLE(SVG)
else if (m_innerURLElement->hasTagName(SVGNames::aTag))
urlString = m_innerURLElement->getAttribute(XLinkNames::hrefAttr);
bool RenderDetails::isOpen() const
{
- return node() && node()->isElementNode() ? !static_cast<Element*>(node())->fastGetAttribute(openAttr).isNull() : false;
+ return node() && node()->isElementNode() ? !static_cast<Element*>(node())->getAttribute(openAttr).isNull() : false;
}
} // namespace WebCore
if (listIndex >= listItems.size())
return String();
- return listItems[listIndex]->fastGetAttribute(aria_labelAttr);
+ return listItems[listIndex]->getAttribute(aria_labelAttr);
}
String RenderMenuList::itemToolTip(unsigned listIndex) const
Node* n = node();
if (!n || !n->isLink() || !n->isElementNode())
return;
- const AtomicString& href = static_cast<Element*>(n)->fastGetAttribute(hrefAttr);
+ const AtomicString& href = static_cast<Element*>(n)->getAttribute(hrefAttr);
if (href.isNull())
return;
context->setURLForRect(n->document()->completeURL(href), rect);
if (node() && style()->autoWrap()) {
// See if nowrap was set.
Length w = styleOrColLogicalWidth();
- String nowrap = static_cast<Element*>(node())->fastGetAttribute(nowrapAttr);
+ String nowrap = static_cast<Element*>(node())->getAttribute(nowrapAttr);
if (!nowrap.isNull() && w.isFixed())
// Nowrap is set, but we didn't actually use it because of the
// fixed width set on the cell. Even so, it is a WinIE/Moz trait
const AtomicString& RenderTextControlSingleLine::autosaveName() const
{
- return static_cast<Element*>(node())->fastGetAttribute(autosaveAttr);
+ return static_cast<Element*>(node())->getAttribute(autosaveAttr);
}
// PopupMenuClient methods
// When the natural size of the video is unavailable, we use the provided
// width and height attributes of the video element as the intrinsic size until
// better values become available.
- if (video->fastHasAttribute(widthAttr) && video->fastHasAttribute(heightAttr))
+ if (video->hasAttribute(widthAttr) && video->hasAttribute(heightAttr))
return IntSize(video->width(), video->height());
// <video> in standalone media documents should not use the default 300x150
Element* fenced = static_cast<Element*>(node());
// FIXME: Handle open/close values with more than one character (they should be treated like text).
- AtomicString openValue = fenced->fastGetAttribute(MathMLNames::openAttr);
+ AtomicString openValue = fenced->getAttribute(MathMLNames::openAttr);
if (openValue.length() > 0)
m_open = openValue[0];
- AtomicString closeValue = fenced->fastGetAttribute(MathMLNames::closeAttr);
+ AtomicString closeValue = fenced->getAttribute(MathMLNames::closeAttr);
if (closeValue.length() > 0)
m_close = closeValue[0];
- AtomicString separators = static_cast<Element*>(fenced)->fastGetAttribute(MathMLNames::separatorsAttr);
+ AtomicString separators = static_cast<Element*>(fenced)->getAttribute(MathMLNames::separatorsAttr);
if (!separators.isNull()) {
Vector<UChar> characters;
for (unsigned int i = 0; i < separators.length(); i++) {
Element* fraction = static_cast<Element*>(node());
RenderObject* numerator = firstChild();
- String nalign = fraction->fastGetAttribute(MathMLNames::numalignAttr);
+ String nalign = fraction->getAttribute(MathMLNames::numalignAttr);
if (equalIgnoringCase(nalign, "left"))
numerator->style()->setTextAlign(LEFT);
else if (equalIgnoringCase(nalign, "right"))
if (!denominator)
return;
- String dalign = fraction->fastGetAttribute(MathMLNames::denomalignAttr);
+ String dalign = fraction->getAttribute(MathMLNames::denomalignAttr);
if (equalIgnoringCase(dalign, "left"))
denominator->style()->setTextAlign(LEFT);
else if (equalIgnoringCase(dalign, "right"))
denominator->style()->setTextAlign(CENTER);
// FIXME: parse units
- String thickness = fraction->fastGetAttribute(MathMLNames::linethicknessAttr);
+ String thickness = fraction->getAttribute(MathMLNames::linethicknessAttr);
m_lineThickness = gLineMedium;
if (equalIgnoringCase(thickness, "thin"))
m_lineThickness = gLineThin;
// We made need the element later if we can't stretch.
if (node()->nodeType() == Node::ELEMENT_NODE) {
if (Element* mo = static_cast<Element*>(node())) {
- AtomicString stretchyAttr = mo->fastGetAttribute(MathMLNames::stretchyAttr);
+ AtomicString stretchyAttr = mo->getAttribute(MathMLNames::stretchyAttr);
stretchDisabled = equalIgnoringCase(stretchyAttr, "false");
// If stretching isn't disabled, get the character from the text content.
isVerticalText = parentRenderObject->style()->svgStyle()->isVerticalWritingMode();
if (Element* parentRenderObjectElement = toElement(parentRenderObject->node())) {
- language = parentRenderObjectElement->fastGetAttribute(XMLNames::langAttr);
+ language = parentRenderObjectElement->getAttribute(XMLNames::langAttr);
if (parentRenderObjectElement->hasTagName(SVGNames::altGlyphTag)) {
SVGAltGlyphElement* altGlyph = static_cast<SVGAltGlyphElement*>(parentRenderObjectElement);
git://git.webkit.org / WebKit-https.git / commitdiff