Changeset 203337 in webkit


Ignore:
Timestamp:
Jul 17, 2016 5:39:37 PM (8 years ago)
Author:
rniwa@webkit.org
Message:

Rename fastHasAttribute to hasAttributeWithoutSynchronization
​https://bugs.webkit.org/show_bug.cgi?id=159864

Reviewed by Chris Dumez.

Source/WebCore:

Renamed Rename fastHasAttribute to hasAttributeWithoutSynchronization for clarity.

  • accessibility/AccessibilityListBoxOption.cpp:

(WebCore::AccessibilityListBoxOption::isEnabled):

  • accessibility/AccessibilityObject.cpp:

(WebCore::AccessibilityObject::hasAttribute):
(WebCore::AccessibilityObject::getAttribute):

  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::determineAccessibilityRole):

  • bindings/scripts/CodeGenerator.pm:

(GetterExpression):

  • bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:
  • bindings/scripts/test/JS/JSTestObj.cpp:

(WebCore::jsTestObjReflectedBooleanAttr):
(WebCore::jsTestObjReflectedCustomBooleanAttr):

  • bindings/scripts/test/ObjC/DOMTestObj.mm:

(-[DOMTestObj reflectedBooleanAttr]):
(-[DOMTestObj setReflectedBooleanAttr:]):
(-[DOMTestObj reflectedCustomBooleanAttr]):
(-[DOMTestObj setReflectedCustomBooleanAttr:]):

  • dom/Document.cpp:

(WebCore::Document::hasManifest):
(WebCore::Document::doctype):

  • dom/Element.h:

(WebCore::Node::parentElement):
(WebCore::Element::hasAttributeWithoutSynchronization):
(WebCore::Element::fastHasAttribute): Deleted.

  • editing/ApplyStyleCommand.cpp:

(WebCore::ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock):

  • editing/DeleteSelectionCommand.cpp:

(WebCore::DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss):

  • editing/markup.cpp:

(WebCore::createMarkupInternal):

  • html/ColorInputType.cpp:

(WebCore::ColorInputType::shouldShowSuggestions):

  • html/FileInputType.cpp:

(WebCore::FileInputType::handleDOMActivateEvent):
(WebCore::FileInputType::receiveDroppedFiles):

  • html/FormAssociatedElement.cpp:

(WebCore::FormAssociatedElement::didMoveToNewDocument):
(WebCore::FormAssociatedElement::insertedInto):
(WebCore::FormAssociatedElement::removedFrom):
(WebCore::FormAssociatedElement::formAttributeChanged):

  • html/FormController.cpp:

(WebCore::ownerFormForState):

  • html/GenericCachedHTMLCollection.cpp:

(WebCore::GenericCachedHTMLCollection<traversalType>::elementMatches):

  • html/HTMLAnchorElement.cpp:

(WebCore::HTMLAnchorElement::draggable):
(WebCore::HTMLAnchorElement::href):
(WebCore::HTMLAnchorElement::sendPings):

  • html/HTMLAppletElement.cpp:

(WebCore::HTMLAppletElement::rendererIsNeeded):

  • html/HTMLElement.cpp:

(WebCore::HTMLElement::collectStyleForPresentationAttribute):
(WebCore::elementAffectsDirectionality):
(WebCore::setHasDirAutoFlagRecursively):

  • html/HTMLEmbedElement.cpp:

(WebCore::HTMLEmbedElement::rendererIsNeeded):

  • html/HTMLFieldSetElement.cpp:

(WebCore::updateFromControlElementsAncestorDisabledStateUnder):
(WebCore::HTMLFieldSetElement::disabledAttributeChanged):
(WebCore::HTMLFieldSetElement::disabledStateChanged):
(WebCore::HTMLFieldSetElement::childrenChanged):

  • html/HTMLFormControlElement.cpp:

(WebCore::HTMLFormControlElement::formNoValidate):
(WebCore::HTMLFormControlElement::formAction):
(WebCore::HTMLFormControlElement::computeIsDisabledByFieldsetAncestor):
(WebCore::shouldAutofocus):

  • html/HTMLFormElement.cpp:

(WebCore::HTMLFormElement::formElementIndex):
(WebCore::HTMLFormElement::noValidate):

  • html/HTMLFrameElement.cpp:

(WebCore::HTMLFrameElement::noResize):
(WebCore::HTMLFrameElement::didAttachRenderers):

  • html/HTMLFrameElementBase.cpp:

(WebCore::HTMLFrameElementBase::parseAttribute):
(WebCore::HTMLFrameElementBase::location):

  • html/HTMLHRElement.cpp:

(WebCore::HTMLHRElement::collectStyleForPresentationAttribute):

  • html/HTMLImageElement.cpp:

(WebCore::HTMLImageElement::isServerMap):

  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::finishParsingChildren):
(WebCore::HTMLInputElement::matchesDefaultPseudoClass):
(WebCore::HTMLInputElement::isActivatedSubmit):
(WebCore::HTMLInputElement::reset):
(WebCore::HTMLInputElement::multiple):
(WebCore::HTMLInputElement::setSize):
(WebCore::HTMLInputElement::shouldUseMediaCapture):

  • html/HTMLMarqueeElement.cpp:

(WebCore::HTMLMarqueeElement::minimumDelay):

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::insertedInto):
(WebCore::HTMLMediaElement::selectMediaResource):
(WebCore::HTMLMediaElement::loadResource):
(WebCore::HTMLMediaElement::autoplay):
(WebCore::HTMLMediaElement::preload):
(WebCore::HTMLMediaElement::loop):
(WebCore::HTMLMediaElement::setLoop):
(WebCore::HTMLMediaElement::controls):
(WebCore::HTMLMediaElement::setControls):
(WebCore::HTMLMediaElement::muted):
(WebCore::HTMLMediaElement::setMuted):
(WebCore::HTMLMediaElement::selectNextSourceChild):
(WebCore::HTMLMediaElement::sourceWasAdded):
(WebCore::HTMLMediaElement::mediaSessionTitle):

  • html/HTMLObjectElement.cpp:

(WebCore::HTMLObjectElement::parseAttribute):

  • html/HTMLOptGroupElement.cpp:

(WebCore::HTMLOptGroupElement::isDisabledFormControl):
(WebCore::HTMLOptGroupElement::isFocusable):

  • html/HTMLOptionElement.cpp:

(WebCore::HTMLOptionElement::matchesDefaultPseudoClass):
(WebCore::HTMLOptionElement::text):

  • html/HTMLProgressElement.cpp:

(WebCore::HTMLProgressElement::isDeterminate):
(WebCore::HTMLProgressElement::didElementStateChange):

  • html/HTMLScriptElement.cpp:

(WebCore::HTMLScriptElement::async):
(WebCore::HTMLScriptElement::setCrossOrigin):
(WebCore::HTMLScriptElement::asyncAttributeValue):
(WebCore::HTMLScriptElement::deferAttributeValue):
(WebCore::HTMLScriptElement::hasSourceAttribute):
(WebCore::HTMLScriptElement::dispatchLoadEvent):

  • html/HTMLSelectElement.cpp:

(WebCore::HTMLSelectElement::reset):

  • html/HTMLTrackElement.cpp:

(WebCore::HTMLTrackElement::isDefault):
(WebCore::HTMLTrackElement::ensureTrack):
(WebCore::HTMLTrackElement::loadTimerFired):

  • html/MediaElementSession.cpp:

(WebCore::MediaElementSession::wirelessVideoPlaybackDisabled):
(WebCore::MediaElementSession::requiresFullscreenForVideoPlayback):
(WebCore::MediaElementSession::allowsAutomaticMediaDataLoading):

  • html/SearchInputType.cpp:

(WebCore::SearchInputType::searchEventsShouldBeDispatched):
(WebCore::SearchInputType::didSetValueByUserEdit):

  • inspector/InspectorDOMAgent.cpp:

(WebCore::InspectorDOMAgent::buildObjectForNode):

  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::shouldTreatURLAsSrcdocDocument):
(WebCore::FrameLoader::findFrameForNavigation):

  • loader/ImageLoader.cpp:

(WebCore::ImageLoader::notifyFinished):

  • mathml/MathMLSelectElement.cpp:

(WebCore::MathMLSelectElement::getSelectedSemanticsChild):

  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::computePreferredLogicalWidths):

  • rendering/RenderThemeIOS.mm:

(WebCore::RenderThemeIOS::adjustMenuListButtonStyle):

  • rendering/SimpleLineLayout.cpp:

(WebCore::SimpleLineLayout::canUseForWithReason):

  • rendering/svg/RenderSVGResourceClipper.cpp:

(WebCore::RenderSVGResourceClipper::drawContentIntoMaskImage):

  • svg/SVGAnimateMotionElement.cpp:

(WebCore::SVGAnimateMotionElement::updateAnimationPath):

  • svg/SVGAnimationElement.cpp:

(WebCore::SVGAnimationElement::startedActiveInterval):
(WebCore::SVGAnimationElement::updateAnimation):

  • svg/animation/SVGSMILElement.cpp:

(WebCore::SVGSMILElement::insertedInto):

Source/WebKit2:

  • WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::getAssistedNodeInformation):

Location:
trunk/Source
Files:
54 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r203334 r203337  
     12016-07-17  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Rename fastHasAttribute to hasAttributeWithoutSynchronization
     4        https://bugs.webkit.org/show_bug.cgi?id=159864
     5
     6        Reviewed by Chris Dumez.
     7
     8        Renamed Rename fastHasAttribute to hasAttributeWithoutSynchronization for clarity.
     9
     10        * accessibility/AccessibilityListBoxOption.cpp:
     11        (WebCore::AccessibilityListBoxOption::isEnabled):
     12        * accessibility/AccessibilityObject.cpp:
     13        (WebCore::AccessibilityObject::hasAttribute):
     14        (WebCore::AccessibilityObject::getAttribute):
     15        * accessibility/AccessibilityRenderObject.cpp:
     16        (WebCore::AccessibilityRenderObject::determineAccessibilityRole):
     17        * bindings/scripts/CodeGenerator.pm:
     18        (GetterExpression):
     19        * bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:
     20        * bindings/scripts/test/JS/JSTestObj.cpp:
     21        (WebCore::jsTestObjReflectedBooleanAttr):
     22        (WebCore::jsTestObjReflectedCustomBooleanAttr):
     23        * bindings/scripts/test/ObjC/DOMTestObj.mm:
     24        (-[DOMTestObj reflectedBooleanAttr]):
     25        (-[DOMTestObj setReflectedBooleanAttr:]):
     26        (-[DOMTestObj reflectedCustomBooleanAttr]):
     27        (-[DOMTestObj setReflectedCustomBooleanAttr:]):
     28        * dom/Document.cpp:
     29        (WebCore::Document::hasManifest):
     30        (WebCore::Document::doctype):
     31        * dom/Element.h:
     32        (WebCore::Node::parentElement):
     33        (WebCore::Element::hasAttributeWithoutSynchronization):
     34        (WebCore::Element::fastHasAttribute): Deleted.
     35        * editing/ApplyStyleCommand.cpp:
     36        (WebCore::ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock):
     37        * editing/DeleteSelectionCommand.cpp:
     38        (WebCore::DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss):
     39        * editing/markup.cpp:
     40        (WebCore::createMarkupInternal):
     41        * html/ColorInputType.cpp:
     42        (WebCore::ColorInputType::shouldShowSuggestions):
     43        * html/FileInputType.cpp:
     44        (WebCore::FileInputType::handleDOMActivateEvent):
     45        (WebCore::FileInputType::receiveDroppedFiles):
     46        * html/FormAssociatedElement.cpp:
     47        (WebCore::FormAssociatedElement::didMoveToNewDocument):
     48        (WebCore::FormAssociatedElement::insertedInto):
     49        (WebCore::FormAssociatedElement::removedFrom):
     50        (WebCore::FormAssociatedElement::formAttributeChanged):
     51        * html/FormController.cpp:
     52        (WebCore::ownerFormForState):
     53        * html/GenericCachedHTMLCollection.cpp:
     54        (WebCore::GenericCachedHTMLCollection<traversalType>::elementMatches):
     55        * html/HTMLAnchorElement.cpp:
     56        (WebCore::HTMLAnchorElement::draggable):
     57        (WebCore::HTMLAnchorElement::href):
     58        (WebCore::HTMLAnchorElement::sendPings):
     59        * html/HTMLAppletElement.cpp:
     60        (WebCore::HTMLAppletElement::rendererIsNeeded):
     61        * html/HTMLElement.cpp:
     62        (WebCore::HTMLElement::collectStyleForPresentationAttribute):
     63        (WebCore::elementAffectsDirectionality):
     64        (WebCore::setHasDirAutoFlagRecursively):
     65        * html/HTMLEmbedElement.cpp:
     66        (WebCore::HTMLEmbedElement::rendererIsNeeded):
     67        * html/HTMLFieldSetElement.cpp:
     68        (WebCore::updateFromControlElementsAncestorDisabledStateUnder):
     69        (WebCore::HTMLFieldSetElement::disabledAttributeChanged):
     70        (WebCore::HTMLFieldSetElement::disabledStateChanged):
     71        (WebCore::HTMLFieldSetElement::childrenChanged):
     72        * html/HTMLFormControlElement.cpp:
     73        (WebCore::HTMLFormControlElement::formNoValidate):
     74        (WebCore::HTMLFormControlElement::formAction):
     75        (WebCore::HTMLFormControlElement::computeIsDisabledByFieldsetAncestor):
     76        (WebCore::shouldAutofocus):
     77        * html/HTMLFormElement.cpp:
     78        (WebCore::HTMLFormElement::formElementIndex):
     79        (WebCore::HTMLFormElement::noValidate):
     80        * html/HTMLFrameElement.cpp:
     81        (WebCore::HTMLFrameElement::noResize):
     82        (WebCore::HTMLFrameElement::didAttachRenderers):
     83        * html/HTMLFrameElementBase.cpp:
     84        (WebCore::HTMLFrameElementBase::parseAttribute):
     85        (WebCore::HTMLFrameElementBase::location):
     86        * html/HTMLHRElement.cpp:
     87        (WebCore::HTMLHRElement::collectStyleForPresentationAttribute):
     88        * html/HTMLImageElement.cpp:
     89        (WebCore::HTMLImageElement::isServerMap):
     90        * html/HTMLInputElement.cpp:
     91        (WebCore::HTMLInputElement::finishParsingChildren):
     92        (WebCore::HTMLInputElement::matchesDefaultPseudoClass):
     93        (WebCore::HTMLInputElement::isActivatedSubmit):
     94        (WebCore::HTMLInputElement::reset):
     95        (WebCore::HTMLInputElement::multiple):
     96        (WebCore::HTMLInputElement::setSize):
     97        (WebCore::HTMLInputElement::shouldUseMediaCapture):
     98        * html/HTMLMarqueeElement.cpp:
     99        (WebCore::HTMLMarqueeElement::minimumDelay):
     100        * html/HTMLMediaElement.cpp:
     101        (WebCore::HTMLMediaElement::insertedInto):
     102        (WebCore::HTMLMediaElement::selectMediaResource):
     103        (WebCore::HTMLMediaElement::loadResource):
     104        (WebCore::HTMLMediaElement::autoplay):
     105        (WebCore::HTMLMediaElement::preload):
     106        (WebCore::HTMLMediaElement::loop):
     107        (WebCore::HTMLMediaElement::setLoop):
     108        (WebCore::HTMLMediaElement::controls):
     109        (WebCore::HTMLMediaElement::setControls):
     110        (WebCore::HTMLMediaElement::muted):
     111        (WebCore::HTMLMediaElement::setMuted):
     112        (WebCore::HTMLMediaElement::selectNextSourceChild):
     113        (WebCore::HTMLMediaElement::sourceWasAdded):
     114        (WebCore::HTMLMediaElement::mediaSessionTitle):
     115        * html/HTMLObjectElement.cpp:
     116        (WebCore::HTMLObjectElement::parseAttribute):
     117        * html/HTMLOptGroupElement.cpp:
     118        (WebCore::HTMLOptGroupElement::isDisabledFormControl):
     119        (WebCore::HTMLOptGroupElement::isFocusable):
     120        * html/HTMLOptionElement.cpp:
     121        (WebCore::HTMLOptionElement::matchesDefaultPseudoClass):
     122        (WebCore::HTMLOptionElement::text):
     123        * html/HTMLProgressElement.cpp:
     124        (WebCore::HTMLProgressElement::isDeterminate):
     125        (WebCore::HTMLProgressElement::didElementStateChange):
     126        * html/HTMLScriptElement.cpp:
     127        (WebCore::HTMLScriptElement::async):
     128        (WebCore::HTMLScriptElement::setCrossOrigin):
     129        (WebCore::HTMLScriptElement::asyncAttributeValue):
     130        (WebCore::HTMLScriptElement::deferAttributeValue):
     131        (WebCore::HTMLScriptElement::hasSourceAttribute):
     132        (WebCore::HTMLScriptElement::dispatchLoadEvent):
     133        * html/HTMLSelectElement.cpp:
     134        (WebCore::HTMLSelectElement::reset):
     135        * html/HTMLTrackElement.cpp:
     136        (WebCore::HTMLTrackElement::isDefault):
     137        (WebCore::HTMLTrackElement::ensureTrack):
     138        (WebCore::HTMLTrackElement::loadTimerFired):
     139        * html/MediaElementSession.cpp:
     140        (WebCore::MediaElementSession::wirelessVideoPlaybackDisabled):
     141        (WebCore::MediaElementSession::requiresFullscreenForVideoPlayback):
     142        (WebCore::MediaElementSession::allowsAutomaticMediaDataLoading):
     143        * html/SearchInputType.cpp:
     144        (WebCore::SearchInputType::searchEventsShouldBeDispatched):
     145        (WebCore::SearchInputType::didSetValueByUserEdit):
     146        * inspector/InspectorDOMAgent.cpp:
     147        (WebCore::InspectorDOMAgent::buildObjectForNode):
     148        * loader/FrameLoader.cpp:
     149        (WebCore::FrameLoader::shouldTreatURLAsSrcdocDocument):
     150        (WebCore::FrameLoader::findFrameForNavigation):
     151        * loader/ImageLoader.cpp:
     152        (WebCore::ImageLoader::notifyFinished):
     153        * mathml/MathMLSelectElement.cpp:
     154        (WebCore::MathMLSelectElement::getSelectedSemanticsChild):
     155        * rendering/RenderTableCell.cpp:
     156        (WebCore::RenderTableCell::computePreferredLogicalWidths):
     157        * rendering/RenderThemeIOS.mm:
     158        (WebCore::RenderThemeIOS::adjustMenuListButtonStyle):
     159        * rendering/SimpleLineLayout.cpp:
     160        (WebCore::SimpleLineLayout::canUseForWithReason):
     161        * rendering/svg/RenderSVGResourceClipper.cpp:
     162        (WebCore::RenderSVGResourceClipper::drawContentIntoMaskImage):
     163        * svg/SVGAnimateMotionElement.cpp:
     164        (WebCore::SVGAnimateMotionElement::updateAnimationPath):
     165        * svg/SVGAnimationElement.cpp:
     166        (WebCore::SVGAnimationElement::startedActiveInterval):
     167        (WebCore::SVGAnimationElement::updateAnimation):
     168        * svg/animation/SVGSMILElement.cpp:
     169        (WebCore::SVGSMILElement::insertedInto):
     170
    11712016-07-17  Brady Eidson  <beidson@apple.com>
    2172

  • trunk/Source/WebCore/accessibility/AccessibilityListBoxOption.cpp

    r195452 r203337  
    6868        return false;
    6969
    70     if (m_optionElement->fastHasAttribute(disabledAttr))
     70    if (m_optionElement->hasAttributeWithoutSynchronization(disabledAttr))
    7171        return false;
    7272   

  • trunk/Source/WebCore/accessibility/AccessibilityObject.cpp

    r203324 r203337  
    19941994        return false;
    19951995   
    1996     return downcast<Element>(*node).fastHasAttribute(attribute);
     1996    return downcast<Element>(*node).hasAttributeWithoutSynchronization(attribute);
    19971997}
    19981998   

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r203324 r203337  
    25442544    if (node && node->isLink())
    25452545        return WebCoreLinkRole;
    2546     if (node && is<HTMLImageElement>(*node) && downcast<HTMLImageElement>(*node).fastHasAttribute(usemapAttr))
     2546    if (node && is<HTMLImageElement>(*node) && downcast<HTMLImageElement>(*node).hasAttributeWithoutSynchronization(usemapAttr))
    25472547        return ImageMapRole;
    25482548    if ((cssBox && cssBox->isListItem()) || (node && node->hasTagName(liTag)))

  • trunk/Source/WebCore/bindings/scripts/CodeGenerator.pm

    r203324 r203337  
    655655        $functionName = "getURLAttribute";
    656656    } elsif ($attributeType eq "boolean") {
    657         $functionName = "fastHasAttribute";
     657        $functionName = "hasAttributeWithoutSynchronization";
    658658    } elsif ($attributeType eq "long") {
    659659        $functionName = "getIntegralAttribute";

  • trunk/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp

    r203324 r203337  
    24632463    g_return_val_if_fail(WEBKIT_DOM_IS_TEST_OBJ(self), FALSE);
    24642464    WebCore::TestObj* item = WebKit::core(self);
    2465     gboolean result = item->fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr);
     2465    gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedbooleanattrAttr);
    24662466    return result;
    24672467}
    … …  
    25352535    g_return_val_if_fail(WEBKIT_DOM_IS_TEST_OBJ(self), FALSE);
    25362536    WebCore::TestObj* item = WebKit::core(self);
    2537     gboolean result = item->fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr);
     2537    gboolean result = item->hasAttributeWithoutSynchronization(WebCore::HTMLNames::customContentBooleanAttrAttr);
    25382538    return result;
    25392539}

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r203324 r203337  
    17981798    }
    17991799    auto& impl = castedThis->wrapped();
    1800     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
     1800    JSValue result = jsBoolean(impl.hasAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedbooleanattrAttr));
    18011801    return JSValue::encode(result);
    18021802}
    … …  
    18581858    }
    18591859    auto& impl = castedThis->wrapped();
    1860     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
     1860    JSValue result = jsBoolean(impl.hasAttributeWithoutSynchronization(WebCore::HTMLNames::customContentBooleanAttrAttr));
    18611861    return JSValue::encode(result);
    18621862}

  • trunk/Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm

    r202761 r203337  
    369369{
    370370    WebCore::JSMainThreadNullState state;
    371     return IMPL->fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr);
     371    return IMPL->hasAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedbooleanattrAttr);
    372372}
    373373
    … …  
    417417{
    418418    WebCore::JSMainThreadNullState state;
    419     return IMPL->fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr);
     419    return IMPL->hasAttributeWithoutSynchronization(WebCore::HTMLNames::customContentBooleanAttrAttr);
    420420}
    421421

  • trunk/Source/WebCore/dom/Document.cpp

    r203324 r203337  
    848848bool Document::hasManifest() const
    849849{
    850     return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->fastHasAttribute(manifestAttr);
     850    return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->hasAttributeWithoutSynchronization(manifestAttr);
    851851}
    852852

  • trunk/Source/WebCore/dom/Element.h

    r203324 r203337  
    8787    // Call this to get the value of an attribute that is known not to be the style
    8888    // attribute or one of the SVG animatable attributes.
    89     bool fastHasAttribute(const QualifiedName&) const;
     89    bool hasAttributeWithoutSynchronization(const QualifiedName&) const;
    9090    const AtomicString& attributeWithoutSynchronization(const QualifiedName&) const;
    9191#ifndef NDEBUG
    … …  
    664664}
    665665
    666 inline bool Element::fastHasAttribute(const QualifiedName& name) const
     666inline bool Element::hasAttributeWithoutSynchronization(const QualifiedName& name) const
    667667{
    668668    ASSERT(fastAttributeLookupAllowed(name));

  • trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

    r203324 r203337  
    531531        // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
    532532        // otherwise it sets the property in the inline style declaration.
    533         if (element.fastHasAttribute(dirAttr)) {
     533        if (element.hasAttributeWithoutSynchronization(dirAttr)) {
    534534            // FIXME: If this is a BDO element, we should probably just remove it if it has no
    535535            // other attributes, like we (should) do with B and I elements.

  • trunk/Source/WebCore/editing/DeleteSelectionCommand.cpp

    r203326 r203337  
    435435    while (node && node != range->pastLastNode()) {
    436436        RefPtr<Node> nextNode = NodeTraversal::next(*node);
    437         if ((is<HTMLStyleElement>(*node) && !downcast<HTMLStyleElement>(*node).fastHasAttribute(scopedAttr)) || is<HTMLLinkElement>(*node)) {
     437        if ((is<HTMLStyleElement>(*node) && !downcast<HTMLStyleElement>(*node).hasAttributeWithoutSynchronization(scopedAttr)) || is<HTMLLinkElement>(*node)) {
    438438            nextNode = NodeTraversal::nextSkippingChildren(*node);
    439439            RefPtr<ContainerNode> rootEditableElement = node->rootEditableElement();

  • trunk/Source/WebCore/editing/markup.cpp

    r203326 r203337  
    630630                // appears to have no effect.
    631631                if ((!fullySelectedRootStyle || !fullySelectedRootStyle->style() || !fullySelectedRootStyle->style()->getPropertyCSSValue(CSSPropertyBackgroundImage))
    632                     && fullySelectedRoot->fastHasAttribute(backgroundAttr))
     632                    && fullySelectedRoot->hasAttributeWithoutSynchronization(backgroundAttr))
    633633                    fullySelectedRootStyle->style()->setProperty(CSSPropertyBackgroundImage, "url('" + fullySelectedRoot->getAttribute(backgroundAttr) + "')");
    634634

  • trunk/Source/WebCore/html/ColorInputType.cpp

    r202626 r203337  
    223223{
    224224#if ENABLE(DATALIST_ELEMENT)
    225     return element().fastHasAttribute(listAttr);
     225    return element().hasAttributeWithoutSynchronization(listAttr);
    226226#else
    227227    return false;

  • trunk/Source/WebCore/html/FileInputType.cpp

    r203322 r203337  
    181181        FileChooserSettings settings;
    182182        HTMLInputElement& input = element();
    183         settings.allowsMultipleFiles = input.fastHasAttribute(multipleAttr);
     183        settings.allowsMultipleFiles = input.hasAttributeWithoutSynchronization(multipleAttr);
    184184        settings.acceptMIMETypes = input.acceptMIMETypes();
    185185        settings.acceptFileExtensions = input.acceptFileExtensions();
    … …  
    405405        files.append(FileChooserFileInfo(path));
    406406
    407     if (input->fastHasAttribute(multipleAttr))
     407    if (input->hasAttributeWithoutSynchronization(multipleAttr))
    408408        filesChosen(files);
    409409    else {

  • trunk/Source/WebCore/html/FormAssociatedElement.cpp

    r203324 r203337  
    6464{
    6565    HTMLElement& element = asHTMLElement();
    66     if (oldDocument && element.fastHasAttribute(formAttr))
     66    if (oldDocument && element.hasAttributeWithoutSynchronization(formAttr))
    6767        resetFormAttributeTargetObserver();
    6868}
    … …  
    7979        return;
    8080
    81     if (element.fastHasAttribute(formAttr))
     81    if (element.hasAttributeWithoutSynchronization(formAttr))
    8282        resetFormAttributeTargetObserver();
    8383}
    … …  
    9797{
    9898    HTMLElement& element = asHTMLElement();
    99     if (insertionPoint.inDocument() && element.fastHasAttribute(formAttr))
     99    if (insertionPoint.inDocument() && element.hasAttributeWithoutSynchronization(formAttr))
    100100        m_formAttributeTargetObserver = nullptr;
    101101    // If the form and element are both in the same tree, preserve the connection to the form.
    … …  
    176176{
    177177    HTMLElement& element = asHTMLElement();
    178     if (!element.fastHasAttribute(formAttr)) {
     178    if (!element.hasAttributeWithoutSynchronization(formAttr)) {
    179179        // The form attribute removed. We need to reset form owner here.
    180180        HTMLFormElement* originalForm = m_form;

  • trunk/Source/WebCore/html/FormController.cpp

    r194819 r203337  
    3636    // state during parsing and form owners of such controls might be
    3737    // indeterminate.
    38     return control.fastHasAttribute(formAttr) ? 0 : control.form();
     38    return control.hasAttributeWithoutSynchronization(formAttr) ? 0 : control.form();
    3939}
    4040

  • trunk/Source/WebCore/html/GenericCachedHTMLCollection.cpp

    r201205 r203337  
    7070        return element.hasTagName(embedTag);
    7171    case DocLinks:
    72         return (element.hasTagName(aTag) || element.hasTagName(areaTag)) && element.fastHasAttribute(hrefAttr);
     72        return (element.hasTagName(aTag) || element.hasTagName(areaTag)) && element.hasAttributeWithoutSynchronization(hrefAttr);
    7373    case DocAnchors:
    74         return element.hasTagName(aTag) && element.fastHasAttribute(nameAttr);
     74        return element.hasTagName(aTag) && element.hasAttributeWithoutSynchronization(nameAttr);
    7575    case ByClass:
    7676    case ByTag:

  • trunk/Source/WebCore/html/HTMLAnchorElement.cpp

    r203326 r203337  
    282282    if (equalLettersIgnoringASCIICase(value, "false"))
    283283        return false;
    284     return fastHasAttribute(hrefAttr);
     284    return hasAttributeWithoutSynchronization(hrefAttr);
    285285}
    286286
    … …  
    350350void HTMLAnchorElement::sendPings(const URL& destinationURL)
    351351{
    352     if (!fastHasAttribute(pingAttr) || !document().settings() || !document().settings()->hyperlinkAuditingEnabled())
     352    if (!hasAttributeWithoutSynchronization(pingAttr) || !document().settings() || !document().settings()->hyperlinkAuditingEnabled())
    353353        return;
    354354

  • trunk/Source/WebCore/html/HTMLAppletElement.cpp

    r203324 r203337  
    7171bool HTMLAppletElement::rendererIsNeeded(const RenderStyle& style)
    7272{
    73     if (!fastHasAttribute(codeAttr))
     73    if (!hasAttributeWithoutSynchronization(codeAttr))
    7474        return false;
    7575    return HTMLPlugInImageElement::rendererIsNeeded(style);

  • trunk/Source/WebCore/html/HTMLElement.cpp

    r203324 r203337  
    244244    else if (name == langAttr) {
    245245        // xml:lang has a higher priority than lang.
    246         if (!fastHasAttribute(XMLNames::langAttr))
     246        if (!hasAttributeWithoutSynchronization(XMLNames::langAttr))
    247247            mapLanguageAttributeToLocale(value, style);
    248248    } else
    … …  
    884884        return false;
    885885    const HTMLElement& element = downcast<HTMLElement>(node);
    886     return is<HTMLBDIElement>(element) || element.fastHasAttribute(dirAttr);
     886    return is<HTMLBDIElement>(element) || element.hasAttributeWithoutSynchronization(dirAttr);
    887887}
    888888

  • trunk/Source/WebCore/html/HTMLEmbedElement.cpp

    r203324 r203337  
    184184bool HTMLEmbedElement::rendererIsNeeded(const RenderStyle& style)
    185185{
    186     if (!fastHasAttribute(typeAttr) && !fastHasAttribute(srcAttr))
     186    if (!hasAttributeWithoutSynchronization(typeAttr) && !hasAttributeWithoutSynchronization(srcAttr))
    187187        return false;
    188188

  • trunk/Source/WebCore/html/HTMLFieldSetElement.cpp

    r201588 r203337  
    6666        control->setAncestorDisabled(isDisabled);
    6767        // Don't call setAncestorDisabled(false) on form controls inside disabled fieldsets.
    68         if (is<HTMLFieldSetElement>(*control) && control->fastHasAttribute(disabledAttr))
     68        if (is<HTMLFieldSetElement>(*control) && control->hasAttributeWithoutSynchronization(disabledAttr))
    6969            control = Traversal<HTMLFormControlElement>::nextSkippingChildren(*control, &startNode);
    7070        else
    … …  
    7575void HTMLFieldSetElement::disabledAttributeChanged()
    7676{
    77     bool hasDisabledAttribute = fastHasAttribute(disabledAttr);
     77    bool hasDisabledAttribute = hasAttributeWithoutSynchronization(disabledAttr);
    7878    if (m_hasDisabledAttribute != hasDisabledAttribute) {
    7979        m_hasDisabledAttribute = hasDisabledAttribute;
    … …  
    9595        return;
    9696
    97     bool thisFieldsetIsDisabled = fastHasAttribute(disabledAttr);
     97    bool thisFieldsetIsDisabled = hasAttributeWithoutSynchronization(disabledAttr);
    9898    bool hasSeenFirstLegendElement = false;
    9999    for (HTMLElement* control = Traversal<HTMLElement>::firstChild(*this); control; control = Traversal<HTMLElement>::nextSibling(*control)) {
    … …  
    110110{
    111111    HTMLFormControlElement::childrenChanged(change);
    112     if (!fastHasAttribute(disabledAttr))
     112    if (!hasAttributeWithoutSynchronization(disabledAttr))
    113113        return;
    114114

  • trunk/Source/WebCore/html/HTMLFormControlElement.cpp

    r203324 r203337  
    104104bool HTMLFormControlElement::formNoValidate() const
    105105{
    106     return fastHasAttribute(formnovalidateAttr);
     106    return hasAttributeWithoutSynchronization(formnovalidateAttr);
    107107}
    108108
    … …  
    124124    Element* previousAncestor = nullptr;
    125125    for (Element* ancestor = parentElement(); ancestor; ancestor = ancestor->parentElement()) {
    126         if (is<HTMLFieldSetElement>(*ancestor) && ancestor->fastHasAttribute(disabledAttr)) {
     126        if (is<HTMLFieldSetElement>(*ancestor) && ancestor->hasAttributeWithoutSynchronization(disabledAttr)) {
    127127            HTMLFieldSetElement& fieldSetAncestor = downcast<HTMLFieldSetElement>(*ancestor);
    128128            bool isInFirstLegend = is<HTMLLegendElement>(previousAncestor) && previousAncestor == fieldSetAncestor.legend();
    … …  
    197197    if (!element->renderer())
    198198        return false;
    199     if (!element->fastHasAttribute(autofocusAttr))
     199    if (!element->hasAttributeWithoutSynchronization(autofocusAttr))
    200200        return false;
    201201    if (!element->inDocument() || !element->document().renderView())

  • trunk/Source/WebCore/html/HTMLFormElement.cpp

    r203324 r203337  
    552552    // Treats separately the case where this element has the form attribute
    553553    // for performance consideration.
    554     if (associatedHTMLElement.fastHasAttribute(formAttr)) {
     554    if (associatedHTMLElement.hasAttributeWithoutSynchronization(formAttr)) {
    555555        unsigned short position = compareDocumentPosition(&associatedHTMLElement);
    556556        if (position & DOCUMENT_POSITION_PRECEDING) {
    … …  
    675675bool HTMLFormElement::noValidate() const
    676676{
    677     return fastHasAttribute(novalidateAttr);
     677    return hasAttributeWithoutSynchronization(novalidateAttr);
    678678}
    679679

  • trunk/Source/WebCore/html/HTMLFrameElement.cpp

    r201588 r203337  
    5959bool HTMLFrameElement::noResize() const
    6060{
    61     return fastHasAttribute(noresizeAttr);
     61    return hasAttributeWithoutSynchronization(noresizeAttr);
    6262}
    6363

  • trunk/Source/WebCore/html/HTMLFrameElementBase.cpp

    r203326 r203337  
    9595    if (name == srcdocAttr)
    9696        setLocation("about:srcdoc");
    97     else if (name == srcAttr && !fastHasAttribute(srcdocAttr))
     97    else if (name == srcAttr && !hasAttributeWithoutSynchronization(srcdocAttr))
    9898        setLocation(stripLeadingAndTrailingHTMLSpaces(value));
    9999    else if (name == idAttr) {
    100100        HTMLFrameOwnerElement::parseAttribute(name, value);
    101101        // Falling back to using the 'id' attribute is not standard but some content relies on this behavior.
    102         if (!fastHasAttribute(nameAttr))
     102        if (!hasAttributeWithoutSynchronization(nameAttr))
    103103            m_frameName = value;
    104104    } else if (name == nameAttr) {
    … …  
    168168URL HTMLFrameElementBase::location() const
    169169{
    170     if (fastHasAttribute(srcdocAttr))
     170    if (hasAttributeWithoutSynchronization(srcdocAttr))
    171171        return URL(ParsedURLString, "about:srcdoc");
    172172    return document().completeURL(attributeWithoutSynchronization(srcAttr));

  • trunk/Source/WebCore/html/HTMLHRElement.cpp

    r195452 r203337  
    8282        addHTMLColorToStyle(style, CSSPropertyBackgroundColor, value);
    8383    } else if (name == noshadeAttr) {
    84         if (!fastHasAttribute(colorAttr)) {
     84        if (!hasAttributeWithoutSynchronization(colorAttr)) {
    8585            addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderStyle, CSSValueSolid);
    8686

  • trunk/Source/WebCore/html/HTMLImageElement.cpp

    r203324 r203337  
    560560bool HTMLImageElement::isServerMap() const
    561561{
    562     if (!fastHasAttribute(ismapAttr))
     562    if (!hasAttributeWithoutSynchronization(ismapAttr))
    563563        return false;
    564564

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r203324 r203337  
    762762    HTMLTextFormControlElement::finishParsingChildren();
    763763    if (!m_stateRestored) {
    764         bool checked = fastHasAttribute(checkedAttr);
     764        bool checked = hasAttributeWithoutSynchronization(checkedAttr);
    765765        if (checked)
    766766            setChecked(checked);
    … …  
    829829    if (m_inputType->canBeSuccessfulSubmitButton())
    830830        return !isDisabledFormControl() && form() && form()->defaultButton() == this;
    831     return m_inputType->isCheckable() && fastHasAttribute(checkedAttr);
     831    return m_inputType->isCheckable() && hasAttributeWithoutSynchronization(checkedAttr);
    832832}
    833833
    … …  
    853853
    854854    setAutoFilled(false);
    855     setChecked(fastHasAttribute(checkedAttr));
     855    setChecked(hasAttributeWithoutSynchronization(checkedAttr));
    856856    m_reflectsCheckedAttribute = true;
    857857}
    … …  
    12831283bool HTMLInputElement::multiple() const
    12841284{
    1285     return fastHasAttribute(multipleAttr);
     1285    return hasAttributeWithoutSynchronization(multipleAttr);
    12861286}
    12871287
    … …  
    17991799bool HTMLInputElement::shouldUseMediaCapture() const
    18001800{
    1801     return isFileUpload() && fastHasAttribute(captureAttr);
     1801    return isFileUpload() && hasAttributeWithoutSynchronization(captureAttr);
    18021802}
    18031803#endif

  • trunk/Source/WebCore/html/HTMLMarqueeElement.cpp

    r203324 r203337  
    5353int HTMLMarqueeElement::minimumDelay() const
    5454{
    55     if (!fastHasAttribute(truespeedAttr)) {
     55    if (!hasAttributeWithoutSynchronization(truespeedAttr)) {
    5656        // WinIE uses 60ms as the minimum delay by default.
    5757        return 60;

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r203324 r203337  
    783783    if (!m_explicitlyMuted) {
    784784        m_explicitlyMuted = true;
    785         m_muted = fastHasAttribute(mutedAttr);
     785        m_muted = hasAttributeWithoutSynchronization(mutedAttr);
    786786    }
    787787
    … …  
    12641264    // 3 - If the media element has a src attribute, then let mode be attribute.
    12651265    Mode mode = attribute;
    1266     if (!fastHasAttribute(srcAttr)) {
     1266    if (!hasAttributeWithoutSynchronization(srcAttr)) {
    12671267        // Otherwise, if the media element does not have a src attribute but has a source
    12681268        // element child, then let mode be children and let candidate be the first such
    … …  
    14221422    if (!m_explicitlyMuted) {
    14231423        m_explicitlyMuted = true;
    1424         m_muted = fastHasAttribute(mutedAttr);
     1424        m_muted = hasAttributeWithoutSynchronization(mutedAttr);
    14251425    }
    14261426
    … …  
    30133013bool HTMLMediaElement::autoplay() const
    30143014{
    3015     return fastHasAttribute(autoplayAttr);
     3015    return hasAttributeWithoutSynchronization(autoplayAttr);
    30163016}
    30173017
    … …  
    32923292bool HTMLMediaElement::loop() const
    32933293{
    3294     return fastHasAttribute(loopAttr);
     3294    return hasAttributeWithoutSynchronization(loopAttr);
    32953295}
    32963296
    … …  
    33093309        return true;
    33103310
    3311     return fastHasAttribute(controlsAttr);
     3311    return hasAttributeWithoutSynchronization(controlsAttr);
    33123312}
    33133313
    … …  
    33443344bool HTMLMediaElement::muted() const
    33453345{
    3346     return m_explicitlyMuted ? m_muted : fastHasAttribute(mutedAttr);
     3346    return m_explicitlyMuted ? m_muted : hasAttributeWithoutSynchronization(mutedAttr);
    33473347}
    33483348
    … …  
    42064206            goto CheckAgain;
    42074207       
    4208         if (source->fastHasAttribute(mediaAttr)) {
     4208        if (source->hasAttributeWithoutSynchronization(mediaAttr)) {
    42094209            auto media = source->mediaQuerySet();
    42104210#if !LOG_DISABLED
    … …  
    42984298   
    42994299    // We should only consider a <source> element when there is not src attribute at all.
    4300     if (fastHasAttribute(srcAttr))
     4300    if (hasAttributeWithoutSynchronization(srcAttr))
    43014301        return;
    43024302
    … …  
    68226822String HTMLMediaElement::mediaSessionTitle() const
    68236823{
    6824     if (fastHasAttribute(titleAttr))
     6824    if (hasAttributeWithoutSynchronization(titleAttr))
    68256825        return attributeWithoutSynchronization(titleAttr);
    68266826   

  • trunk/Source/WebCore/html/HTMLObjectElement.cpp

    r203324 r203337  
    114114    else if (name == typeAttr) {
    115115        m_serviceType = value.string().left(value.find(';')).convertToASCIILowercase();
    116         invalidateRenderer = !fastHasAttribute(classidAttr);
     116        invalidateRenderer = !hasAttributeWithoutSynchronization(classidAttr);
    117117        setNeedsWidgetUpdate(true);
    118118    } else if (name == dataAttr) {
    … …  
    124124            m_imageLoader->updateFromElementIgnoringPreviousError();
    125125        }
    126         invalidateRenderer = !fastHasAttribute(classidAttr);
     126        invalidateRenderer = !hasAttributeWithoutSynchronization(classidAttr);
    127127        setNeedsWidgetUpdate(true);
    128128    } else if (name == classidAttr) {

  • trunk/Source/WebCore/html/HTMLOptGroupElement.cpp

    r203324 r203337  
    5151bool HTMLOptGroupElement::isDisabledFormControl() const
    5252{
    53     return fastHasAttribute(disabledAttr);
     53    return hasAttributeWithoutSynchronization(disabledAttr);
    5454}
    5555

  • trunk/Source/WebCore/html/HTMLOptionElement.cpp

    r203324 r203337  
    9999bool HTMLOptionElement::matchesDefaultPseudoClass() const
    100100{
    101     return fastHasAttribute(selectedAttr);
     101    return hasAttributeWithoutSynchronization(selectedAttr);
    102102}
    103103

  • trunk/Source/WebCore/html/HTMLProgressElement.cpp

    r203324 r203337  
    132132bool HTMLProgressElement::isDeterminate() const
    133133{
    134     return fastHasAttribute(valueAttr);
     134    return hasAttributeWithoutSynchronization(valueAttr);
    135135}
    136136   

  • trunk/Source/WebCore/html/HTMLScriptElement.cpp

    r203324 r203337  
    103103bool HTMLScriptElement::async() const
    104104{
    105     return fastHasAttribute(asyncAttr) || forceAsync();
     105    return hasAttributeWithoutSynchronization(asyncAttr) || forceAsync();
    106106}
    107107
    … …  
    160160bool HTMLScriptElement::asyncAttributeValue() const
    161161{
    162     return fastHasAttribute(asyncAttr);
     162    return hasAttributeWithoutSynchronization(asyncAttr);
    163163}
    164164
    165165bool HTMLScriptElement::deferAttributeValue() const
    166166{
    167     return fastHasAttribute(deferAttr);
     167    return hasAttributeWithoutSynchronization(deferAttr);
    168168}
    169169
    170170bool HTMLScriptElement::hasSourceAttribute() const
    171171{
    172     return fastHasAttribute(srcAttr);
     172    return hasAttributeWithoutSynchronization(srcAttr);
    173173}
    174174

  • trunk/Source/WebCore/html/HTMLSelectElement.cpp

    r203302 r203337  
    10631063
    10641064        HTMLOptionElement& option = downcast<HTMLOptionElement>(*element);
    1065         if (option.fastHasAttribute(selectedAttr)) {
     1065        if (option.hasAttributeWithoutSynchronization(selectedAttr)) {
    10661066            if (selectedOption && !m_multiple)
    10671067                selectedOption->setSelectedState(false);

  • trunk/Source/WebCore/html/HTMLTrackElement.cpp

    r203324 r203337  
    136136bool HTMLTrackElement::isDefault() const
    137137{
    138     return fastHasAttribute(defaultAttr);
     138    return hasAttributeWithoutSynchronization(defaultAttr);
    139139}
    140140
    … …  
    184184void HTMLTrackElement::loadTimerFired()
    185185{
    186     if (!fastHasAttribute(srcAttr))
     186    if (!hasAttributeWithoutSynchronization(srcAttr))
    187187        return;
    188188

  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r203324 r203337  
    315315    }
    316316
    317     if (element.fastHasAttribute(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
     317    if (element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
    318318        LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
    319319        return true;
    … …  
    456456        return true;
    457457
    458     return settings->inlineMediaPlaybackRequiresPlaysInlineAttribute() && !(element.fastHasAttribute(HTMLNames::webkit_playsinlineAttr) || element.fastHasAttribute(HTMLNames::playsinlineAttr));
     458    return settings->inlineMediaPlaybackRequiresPlaysInlineAttribute() && !(element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) || element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr));
    459459}
    460460

  • trunk/Source/WebCore/html/SearchInputType.cpp

    r203322 r203337  
    181181bool SearchInputType::searchEventsShouldBeDispatched() const
    182182{
    183     return element().fastHasAttribute(incrementalAttr);
     183    return element().hasAttributeWithoutSynchronization(incrementalAttr);
    184184}
    185185

  • trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp

    r203322 r203337  
    13801380            value->setTemplateContent(buildObjectForNode(&downcast<HTMLTemplateElement>(element).content(), 0, nodesMap));
    13811381
    1382         if (is<HTMLStyleElement>(element) || (is<HTMLScriptElement>(element) && !element.fastHasAttribute(HTMLNames::srcAttr)))
     1382        if (is<HTMLStyleElement>(element) || (is<HTMLScriptElement>(element) && !element.hasAttributeWithoutSynchronization(HTMLNames::srcAttr)))
    13831383            value->setContentSecurityPolicyHash(computeContentSecurityPolicySHA256Hash(element));
    13841384

  • trunk/Source/WebCore/loader/FrameLoader.cpp

    r203324 r203337  
    32633263    if (!ownerElement->hasTagName(iframeTag))
    32643264        return false;
    3265     return ownerElement->fastHasAttribute(srcdocAttr);
     3265    return ownerElement->hasAttributeWithoutSynchronization(srcdocAttr);
    32663266}
    32673267

  • trunk/Source/WebCore/loader/ImageLoader.cpp

    r203324 r203337  
    287287        return;
    288288
    289     if (element().fastHasAttribute(HTMLNames::crossoriginAttr) && !resource->passesSameOriginPolicyCheck(*element().document().securityOrigin())) {
     289    if (element().hasAttributeWithoutSynchronization(HTMLNames::crossoriginAttr) && !resource->passesSameOriginPolicyCheck(*element().document().securityOrigin())) {
    290290        clearImageWithoutConsideringPendingLoadEvent();
    291291

  • trunk/Source/WebCore/mathml/MathMLSelectElement.cpp

    r203326 r203337  
    175175        if (child->hasTagName(MathMLNames::annotationTag)) {
    176176            // If the <annotation> element has an src attribute then it is a reference to arbitrary binary data and it is not clear whether we can display it. Hence we just ignore the annotation.
    177             if (child->fastHasAttribute(MathMLNames::srcAttr))
     177            if (child->hasAttributeWithoutSynchronization(MathMLNames::srcAttr))
    178178                continue;
    179179            // Otherwise, we assume it is a text annotation that can always be displayed and we stop here.
    … …  
    183183        if (child->hasTagName(MathMLNames::annotation_xmlTag)) {
    184184            // If the <annotation-xml> element has an src attribute then it is a reference to arbitrary binary data and it is not clear whether we can display it. Hence we just ignore the annotation.
    185             if (child->fastHasAttribute(MathMLNames::srcAttr))
     185            if (child->hasAttributeWithoutSynchronization(MathMLNames::srcAttr))
    186186                continue;
    187187            // If the <annotation-xml> element has an encoding attribute describing presentation MathML, SVG or HTML we assume the content can be displayed and we stop here.

  • trunk/Source/WebCore/rendering/RenderTableCell.cpp

    r201635 r203337  
    184184
    185185    RenderBlockFlow::computePreferredLogicalWidths();
    186     if (!element() || !style().autoWrap() || !element()->fastHasAttribute(nowrapAttr))
     186    if (!element() || !style().autoWrap() || !element()->hasAttributeWithoutSynchronization(nowrapAttr))
    187187        return;
    188188

  • trunk/Source/WebCore/rendering/RenderThemeIOS.mm

    r203326 r203337  
    626626    // or a date input. We don't force these if this is just an element with
    627627    // "-webkit-appearance: menulist-button".
    628     if (is<HTMLSelectElement>(*element) && !element->fastHasAttribute(HTMLNames::multipleAttr))
     628    if (is<HTMLSelectElement>(*element) && !element->hasAttributeWithoutSynchronization(HTMLNames::multipleAttr))
    629629        adjustSelectListButtonStyle(style, *element);
    630630    else if (is<HTMLInputElement>(*element))

  • trunk/Source/WebCore/rendering/SimpleLineLayout.cpp

    r199156 r203337  
    299299        SET_REASON_AND_RETURN_IF_NEEDED(FlowParentIsPlaceholderElement, reasons, includeReasons);
    300300    // FIXME: Implementation of wrap=hard looks into lineboxes.
    301     if (flow.parent()->isTextArea() && flow.parent()->element()->fastHasAttribute(HTMLNames::wrapAttr))
     301    if (flow.parent()->isTextArea() && flow.parent()->element()->hasAttributeWithoutSynchronization(HTMLNames::wrapAttr))
    302302        SET_REASON_AND_RETURN_IF_NEEDED(FlowParentIsTextAreaWithWrapping, reasons, includeReasons);
    303303    // This currently covers <blockflow>#text</blockflow>, <blockflow>#text<br></blockflow> and mutiple (sibling) RenderText cases.

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceClipper.cpp

    r200540 r203337  
    216216            if (!renderer)
    217217                continue;
    218             if (!useElement.fastHasAttribute(SVGNames::clip_ruleAttr))
     218            if (!useElement.hasAttributeWithoutSynchronization(SVGNames::clip_ruleAttr))
    219219                newClipRule = renderer->style().svgStyle().clipRule();
    220220        }

  • trunk/Source/WebCore/svg/SVGAnimateMotionElement.cpp

    r194819 r203337  
    133133    }
    134134
    135     if (!foundMPath && fastHasAttribute(SVGNames::pathAttr))
     135    if (!foundMPath && hasAttributeWithoutSynchronization(SVGNames::pathAttr))
    136136        m_animationPath = m_path;
    137137

  • trunk/Source/WebCore/svg/SVGAnimationElement.cpp

    r203324 r203337  
    554554
    555555    // These validations are appropriate for all animation modes.
    556     if (fastHasAttribute(SVGNames::keyPointsAttr) && m_keyPoints.size() != m_keyTimes.size())
     556    if (hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) && m_keyPoints.size() != m_keyTimes.size())
    557557        return;
    558558
    … …  
    562562        unsigned splinesCount = m_keySplines.size();
    563563        if (!splinesCount
    564             || (fastHasAttribute(SVGNames::keyPointsAttr) && m_keyPoints.size() - 1 != splinesCount)
     564            || (hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) && m_keyPoints.size() - 1 != splinesCount)
    565565            || (animationMode == ValuesAnimation && m_values.size() - 1 != splinesCount)
    566             || (fastHasAttribute(SVGNames::keyTimesAttr) && m_keyTimes.size() - 1 != splinesCount))
     566            || (hasAttributeWithoutSynchronization(SVGNames::keyTimesAttr) && m_keyTimes.size() - 1 != splinesCount))
    567567            return;
    568568    }
    … …  
    574574        return;
    575575    if ((animationMode == FromToAnimation || animationMode == FromByAnimation || animationMode == ToAnimation || animationMode == ByAnimation)
    576         && (fastHasAttribute(SVGNames::keyPointsAttr) && fastHasAttribute(SVGNames::keyTimesAttr) && (m_keyTimes.size() < 2 || m_keyTimes.size() != m_keyPoints.size())))
     576        && (hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) && hasAttributeWithoutSynchronization(SVGNames::keyTimesAttr) && (m_keyTimes.size() < 2 || m_keyTimes.size() != m_keyPoints.size())))
    577577        return;
    578578    if (animationMode == FromToAnimation)
    … …  
    588588    else if (animationMode == ValuesAnimation) {
    589589        m_animationValid = m_values.size() >= 1
    590             && (calcMode == CalcModePaced || !fastHasAttribute(SVGNames::keyTimesAttr) || fastHasAttribute(SVGNames::keyPointsAttr) || (m_values.size() == m_keyTimes.size()))
     590            && (calcMode == CalcModePaced || !hasAttributeWithoutSynchronization(SVGNames::keyTimesAttr) || hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_values.size() == m_keyTimes.size()))
    591591            && (calcMode == CalcModeDiscrete || !m_keyTimes.size() || m_keyTimes.last() == 1)
    592592            && (calcMode != CalcModeSpline || ((m_keySplines.size() && (m_keySplines.size() == m_values.size() - 1)) || m_keySplines.size() == m_keyPoints.size() - 1))
    593             && (!fastHasAttribute(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size()));
     593            && (!hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size()));
    594594        if (m_animationValid)
    595595            m_animationValid = calculateToAtEndOfDurationValue(m_values.last());
    … …  
    597597            calculateKeyTimesForCalcModePaced();
    598598    } else if (animationMode == PathAnimation)
    599         m_animationValid = calcMode == CalcModePaced || !fastHasAttribute(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size());
     599        m_animationValid = calcMode == CalcModePaced || !hasAttributeWithoutSynchronization(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size());
    600600}
    601601

  • trunk/Source/WebCore/svg/animation/SVGSMILElement.cpp

    r203324 r203337  
    268268
    269269    // "If no attribute is present, the default begin value (an offset-value of 0) must be evaluated."
    270     if (!fastHasAttribute(SVGNames::beginAttr))
     270    if (!hasAttributeWithoutSynchronization(SVGNames::beginAttr))
    271271        m_beginTimes.append(SMILTimeWithOrigin());
    272272

  • trunk/Source/WebKit2/ChangeLog

    r203335 r203337  
     12016-07-17  Ryosuke Niwa  <rniwa@webkit.org>
     2
     3        Rename fastHasAttribute to hasAttributeWithoutSynchronization
     4        https://bugs.webkit.org/show_bug.cgi?id=159864
     5
     6        Reviewed by Chris Dumez.
     7
     8        * WebProcess/WebPage/ios/WebPageIOS.mm:
     9        (WebKit::WebPage::getAssistedNodeInformation):
     10
    1112016-07-17  Jeremy Jones  <jeremyj@apple.com>
    212

  • trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

    r203324 r203337  
    25602560            if (is<HTMLOptionElement>(*item)) {
    25612561                HTMLOptionElement& option = downcast<HTMLOptionElement>(*item);
    2562                 information.selectOptions.append(OptionItem(option.text(), false, parentGroupID, option.selected(), option.fastHasAttribute(WebCore::HTMLNames::disabledAttr)));
     2562                information.selectOptions.append(OptionItem(option.text(), false, parentGroupID, option.selected(), option.hasAttributeWithoutSynchronization(WebCore::HTMLNames::disabledAttr)));
    25632563            } else if (is<HTMLOptGroupElement>(*item)) {
    25642564                HTMLOptGroupElement& group = downcast<HTMLOptGroupElement>(*item);
    25652565                parentGroupID++;
    2566                 information.selectOptions.append(OptionItem(group.groupLabelText(), true, 0, false, group.fastHasAttribute(WebCore::HTMLNames::disabledAttr)));
     2566                information.selectOptions.append(OptionItem(group.groupLabelText(), true, 0, false, group.hasAttributeWithoutSynchronization(WebCore::HTMLNames::disabledAttr)));
    25672567            }
    25682568        }
Note: See TracChangeset for help on using the changeset viewer.