Introduce Element::AttributeModificationParams

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 1239 matching lines @@
 }
 
 static inline AtomicString makeIdForStyleResolution(const AtomicString& value,
                                                     bool inQuirksMode) {
   if (inQuirksMode)
     return value.lowerASCII();
   return value;
 }
 
 DISABLE_CFI_PERF
-void Element::attributeChanged(const QualifiedName& name,
-                               const AtomicString& oldValue,
-                               const AtomicString& newValue,
-                               AttributeModificationReason reason) {
+void Element::attributeChanged(const AttributeModificationParams& params) {
+  const QualifiedName& name = params.name;
   if (ElementShadow* parentElementShadow =
           shadowWhereNodeCanBeDistributedForV0(*this)) {
     if (shouldInvalidateDistributionWhenAttributeChanged(parentElementShadow,
-                                                         name, newValue))
+                                                         name, params.newValue))
       parentElementShadow->setNeedsDistributionRecalc();
   }
-  if (name == HTMLNames::slotAttr && oldValue != newValue) {
-    if (ShadowRoot* root = v1ShadowRootOfParent())
-      root->ensureSlotAssignment().hostChildSlotNameChanged(oldValue, newValue);
+  if (name == HTMLNames::slotAttr && params.oldValue != params.newValue) {
+    if (ShadowRoot* root = v1ShadowRootOfParent()) {
+      root->ensureSlotAssignment().hostChildSlotNameChanged(params.oldValue,
+                                                            params.newValue);
+    }
   }
 
-  parseAttribute(name, oldValue, newValue);
+  parseAttribute(params);
 
   document().incDOMTreeVersion();
 
   if (name == HTMLNames::idAttr) {
     AtomicString oldId = elementData()->idForStyleResolution();
     AtomicString newId =
-        makeIdForStyleResolution(newValue, document().inQuirksMode());
+        makeIdForStyleResolution(params.newValue, document().inQuirksMode());
     if (newId != oldId) {
       elementData()->setIdForStyleResolution(newId);
       document().styleEngine().idChangedForElement(oldId, newId, *this);
     }
   } else if (name == classAttr) {
-    classAttributeChanged(newValue);
+    classAttributeChanged(params.newValue);
   } else if (name == HTMLNames::nameAttr) {
-    setHasName(!newValue.isNull());
+    setHasName(!params.newValue.isNull());
   } else if (isStyledElement()) {
     if (name == styleAttr) {
-      styleAttributeChanged(newValue, reason);
+      styleAttributeChanged(params.newValue, params.reason);
     } else if (isPresentationAttribute(name)) {
       elementData()->m_presentationAttributeStyleIsDirty = true;
       setNeedsStyleRecalc(LocalStyleChange,
                           StyleChangeReasonForTracing::fromAttribute(name));
     }
   }
 
   invalidateNodeListCachesInAncestors(&name, this);
 
   // If there is currently no StyleResolver, we can't be sure that this
   // attribute change won't affect style.
   if (!document().styleResolver())
     setNeedsStyleRecalc(SubtreeStyleChange,
                         StyleChangeReasonForTracing::fromAttribute(name));
 
   if (isConnected()) {
     if (AXObjectCache* cache = document().existingAXObjectCache())
       cache->handleAttributeChanged(name, this);
   }
 
-  if (reason == AttributeModificationReason::kDirectly &&
+  if (params.reason == AttributeModificationReason::kDirectly &&
       name == tabindexAttr && adjustedFocusedElementInTreeScope() == this) {
     // The attribute change may cause supportsFocus() to return false
     // for the element which had focus.
     //
     // TODO(tkent): We should avoid updating style.  We'd like to check only
     // DOM-level focusability here.
     document().updateStyleAndLayoutTreeForNode(this);
     if (!supportsFocus())
       blur();
   }
 }
 
 bool Element::hasLegalLinkAttribute(const QualifiedName&) const {
   return false;
 }
 
 const QualifiedName& Element::subResourceAttributeName() const {
   return QualifiedName::null();
 }
 
 inline void Element::attributeChangedFromParserOrByCloning(
     const QualifiedName& name,
     const AtomicString& newValue,
     AttributeModificationReason reason) {
   if (name == isAttr)
     V0CustomElementRegistrationContext::setTypeExtension(this, newValue);
-  attributeChanged(name, nullAtom, newValue, reason);
+  attributeChanged(
+      AttributeModificationParams(name, nullAtom, newValue, reason));
 }
 
 template <typename CharacterType>
 static inline ClassStringContent classStringHasClassName(
     const CharacterType* characters,
     unsigned length) {
   DCHECK_GT(length, 0u);
 
   unsigned i = 0;
   do {
@@ skipping 1092 matching lines @@
   if (index == kNotFound) {
     exceptionState.throwDOMException(
         NotFoundError, "The attribute was not found on this element.");
     return nullptr;
   }
 
   detachAttrNodeAtIndex(attr, index);
   return attr;
 }
 
-void Element::parseAttribute(const QualifiedName& name,
-                             const AtomicString&,
-                             const AtomicString& value) {
-  if (name == tabindexAttr) {
+void Element::parseAttribute(const AttributeModificationParams& params) {
+  if (params.name == tabindexAttr) {
     int tabindex = 0;
-    if (value.isEmpty() || !parseHTMLInteger(value, tabindex)) {
+    if (params.newValue.isEmpty() ||
+        !parseHTMLInteger(params.newValue, tabindex)) {
       clearTabIndexExplicitlyIfNeeded();
     } else {
       // We only set when value is in integer range.
       setTabIndexExplicitly();
     }
-  } else if (name == XMLNames::langAttr) {
+  } else if (params.name == XMLNames::langAttr) {
     pseudoStateChanged(CSSSelector::PseudoLang);
   }
 }
 
 bool Element::parseAttributeName(QualifiedName& out,
                                  const AtomicString& namespaceURI,
                                  const AtomicString& qualifiedName,
                                  ExceptionState& exceptionState) {
   AtomicString prefix, localName;
   if (!Document::parseQualifiedName(qualifiedName, prefix, localName,
@@ skipping 1061 matching lines @@
         MutationRecord::createAttributes(this, name, oldValue));
 
   InspectorInstrumentation::willModifyDOMAttr(this, oldValue, newValue);
 }
 
 DISABLE_CFI_PERF
 void Element::didAddAttribute(const QualifiedName& name,
                               const AtomicString& value) {
   if (name == HTMLNames::idAttr)
     updateId(nullAtom, value);
-  attributeChanged(name, nullAtom, value,
-                   AttributeModificationReason::kDirectly);
+  attributeChanged(AttributeModificationParams(
+      name, nullAtom, value, AttributeModificationReason::kDirectly));
   InspectorInstrumentation::didModifyDOMAttr(this, name, value);
   dispatchSubtreeModifiedEvent();
 }
 
 void Element::didModifyAttribute(const QualifiedName& name,
                                  const AtomicString& oldValue,
                                  const AtomicString& newValue) {
   if (name == HTMLNames::idAttr)
     updateId(oldValue, newValue);
-  attributeChanged(name, oldValue, newValue,
-                   AttributeModificationReason::kDirectly);
+  attributeChanged(AttributeModificationParams(
+      name, oldValue, newValue, AttributeModificationReason::kDirectly));
   InspectorInstrumentation::didModifyDOMAttr(this, name, newValue);
   // Do not dispatch a DOMSubtreeModified event here; see bug 81141.
 }
 
 void Element::didRemoveAttribute(const QualifiedName& name,
                                  const AtomicString& oldValue) {
   if (name == HTMLNames::idAttr)
     updateId(oldValue, nullAtom);
-  attributeChanged(name, oldValue, nullAtom,
-                   AttributeModificationReason::kDirectly);
+  attributeChanged(AttributeModificationParams(
+      name, oldValue, nullAtom, AttributeModificationReason::kDirectly));
   InspectorInstrumentation::didRemoveDOMAttr(this, name);
   dispatchSubtreeModifiedEvent();
 }
 
 static bool needsURLResolutionForInlineStyle(const Element& element,
                                              const Document& oldDocument,
                                              const Document& newDocument) {
   if (oldDocument == newDocument)
     return false;
   if (oldDocument.baseURL() == newDocument.baseURL())
@@ skipping 500 matching lines @@
   Vector<String, 4> argv;
   argv.push_back(element);
   argv.push_back(fastGetAttribute(attr1));
   argv.push_back(fastGetAttribute(attr2));
   argv.push_back(fastGetAttribute(attr3));
   activityLogger->logEvent("blinkAddElement", argv.size(), argv.data());
 }
 
 void Element::logUpdateAttributeIfIsolatedWorldAndInDocument(
     const char element[],
-    const QualifiedName& attributeName,
-    const AtomicString& oldValue,
-    const AtomicString& newValue) {
+    const AttributeModificationParams& params) {
   if (!isConnected())
     return;
   V8DOMActivityLogger* activityLogger =
       V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
   if (!activityLogger)
     return;
   Vector<String, 4> argv;
   argv.push_back(element);
-  argv.push_back(attributeName.toString());
-  argv.push_back(oldValue);
-  argv.push_back(newValue);
+  argv.push_back(params.name.toString());
+  argv.push_back(params.oldValue);
+  argv.push_back(params.newValue);
   activityLogger->logEvent("blinkSetAttribute", argv.size(), argv.data());
 }
 
 DEFINE_TRACE(Element) {
   if (hasRareData())
     visitor->trace(elementRareData());
   visitor->trace(m_elementData);
   ContainerNode::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink