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) {
+    // supportsFocus() behavior depends on element classes. It's hard to avoid
+    // to call it, and it needs up-to-date style.

[kochi, 2016/12/21 05:58:09]

nit: s/avoid to call/avoid calling/

Let me understand the comment correctly.
"depends on element classes" = supportsFocus() is virtual for
element C++ classes?  I'm not sure why "It's hard to avoid" from
the comment.

Does the below sound correct?
// The attribute change may cause supportsFocus() to return false
// for the element which had focus, because some elements use
// attributes and up-to-date style to determine focusability.

[tkent, 2016/12/21 06:51:15]

We don't call supportsFocus() and updateStyleAndLayoutTreeForNode() for |href|
and |disabled| attribute change because their behavior are fixed.
tabindex change won't affect style, so I'm unwilling to call
updateStyleAndLayoutTreeForNode().
This is also correct though it doesn't include the unwillingness of
updateStyleAndLayoutTreeForNode().
Your comment and a TODO() would be better?

// The attribute change may cause supportsFocus() to return false
// for the element which had focus, because some elements use
// attributes and up-to-date style to determine focusability.
// TODO(tkent): tabindex doesn't affect style. We should avoid to
// update style if possible.

[kochi, 2016/12/21 08:05:19]

Looks good.

+    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