Blur immediately if an attribute change made an element unfocasable.

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 1292 matching lines @@
   // 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 &&
+      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();
 }
 
@@ skipping 158 matching lines @@
               ->cachedShareableElementDataWithAttributes(attributeVector);
     else
       m_elementData =
           ShareableElementData::createWithAttributes(attributeVector);
   }
 
   parserDidSetAttributes();
 
   // Use attributeVector instead of m_elementData because attributeChanged might
   // modify m_elementData.
-  for (const auto& attribute : attributeVector)
-    attributeChangedFromParserOrByCloning(attribute.name(), attribute.value(),
-                                          ModifiedDirectly);
+  for (const auto& attribute : attributeVector) {
+    attributeChangedFromParserOrByCloning(
+        attribute.name(), attribute.value(),
+        AttributeModificationReason::kByParser);
+  }
 }
 
 bool Element::hasEquivalentAttributes(const Element* other) const {
   synchronizeAllAttributes();
   other->synchronizeAllAttributes();
   if (elementData() == other->elementData())
     return true;
   if (elementData())
     return elementData()->isEquivalent(other->elementData());
   if (other->elementData())
@@ skipping 933 matching lines @@
   return attr;
 }
 
 void Element::parseAttribute(const QualifiedName& name,
                              const AtomicString&,
                              const AtomicString& value) {
   if (name == tabindexAttr) {
     int tabindex = 0;
     if (value.isEmpty() || !parseHTMLInteger(value, tabindex)) {
       clearTabIndexExplicitlyIfNeeded();
-      if (adjustedFocusedElementInTreeScope() == this) {
-        // We might want to call blur(), but it's dangerous to dispatch
-        // events here.
-        document().setNeedsFocusedElementCheck();
-      }
     } else {
       // We only set when value is in integer range.
       setTabIndexExplicitly();
     }
   } else if (name == XMLNames::langAttr) {
     pseudoStateChanged(CSSSelector::PseudoLang);
   }
 }
 
 bool Element::parseAttributeName(QualifiedName& out,
@@ skipping 1058 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);
+  attributeChanged(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);
+  attributeChanged(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);
+  attributeChanged(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 176 matching lines @@
         toUniqueElementData(other.m_elementData)->makeShareableCopy();
 
   if (!other.m_elementData->isUnique() &&
       !ownerDocumentsHaveDifferentCaseSensitivity &&
       !needsURLResolutionForInlineStyle(other, other.document(), document()))
     m_elementData = other.m_elementData;
   else
     m_elementData = other.m_elementData->makeUniqueCopy();
 
   AttributeCollection attributes = m_elementData->attributes();
-  for (const Attribute& attr : attributes)
-    attributeChangedFromParserOrByCloning(attr.name(), attr.value(),
-                                          ModifiedByCloning);
+  for (const Attribute& attr : attributes) {
+    attributeChangedFromParserOrByCloning(
+        attr.name(), attr.value(), AttributeModificationReason::kByCloning);
+  }
 }
 
 void Element::cloneDataFromElement(const Element& other) {
   cloneAttributesFromElement(other);
   copyNonAttributePropertiesFromElement(other);
 }
 
 void Element::createUniqueElementData() {
   if (!m_elementData) {
     m_elementData = UniqueElementData::create();
@@ skipping 74 matching lines @@
 void Element::styleAttributeChanged(
     const AtomicString& newStyleString,
     AttributeModificationReason modificationReason) {
   DCHECK(isStyledElement());
   WTF::OrdinalNumber startLineNumber = WTF::OrdinalNumber::beforeFirst();
   if (document().scriptableDocumentParser() && !document().isInDocumentWrite())
     startLineNumber = document().scriptableDocumentParser()->lineNumber();
 
   if (newStyleString.isNull()) {
     ensureUniqueElementData().m_inlineStyle.clear();
-  } else if (modificationReason == ModifiedByCloning ||
+  } else if (modificationReason == AttributeModificationReason::kByCloning ||
              ContentSecurityPolicy::shouldBypassMainWorld(&document()) ||
              (containingShadowRoot() &&
               containingShadowRoot()->type() == ShadowRootType::UserAgent) ||
              document().contentSecurityPolicy()->allowInlineStyle(
                  this, document().url(), String(), startLineNumber,
                  newStyleString)) {
     setInlineStyleFromString(newStyleString);
   }
 
   elementData()->m_styleAttributeIsDirty = false;
@@ skipping 237 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink