Blur immediately if an attribute change made an element unfocasable.

third_party/WebKit/Source/core/html/HTMLFormControlElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 21 matching lines @@
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLegendElement.h"
 #include "core/html/ValidityState.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/page/Page.h"
 #include "core/page/ValidationMessageClient.h"
+#include "platform/EventDispatchForbiddenScope.h"
 #include "platform/text/BidiTextRun.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName,
                                                Document& document)
     : LabelableElement(tagName, document),
@@ skipping 76 matching lines @@
 void HTMLFormControlElement::ancestorDisabledStateWasChanged() {
   m_ancestorDisabledState = AncestorDisabledStateUnknown;
   disabledAttributeChanged();
 }
 
 void HTMLFormControlElement::reset() {
   setAutofilled(false);
   resetImpl();
 }
 
+void HTMLFormControlElement::attributeChanged(
+    const QualifiedName& name,
+    const AtomicString& oldValue,
+    const AtomicString& newValue,
+    AttributeModificationReason reason) {
+  HTMLElement::attributeChanged(name, oldValue, newValue, reason);
+  if (name == disabledAttr && oldValue.isNull() != newValue.isNull()) {
+    disabledAttributeChanged();
+    if (reason == AttributeModificationReason::kDirectly &&
+        isDisabledFormControl() && adjustedFocusedElementInTreeScope() == this)
+      blur();
+  }
+}
+
 void HTMLFormControlElement::parseAttribute(const QualifiedName& name,
                                             const AtomicString& oldValue,
                                             const AtomicString& value) {
   if (name == formAttr) {
     formAttributeChanged();
     UseCounter::count(document(), UseCounter::FormAttribute);
-  } else if (name == disabledAttr) {
-    if (oldValue.isNull() != value.isNull())
-      disabledAttributeChanged();
   } else if (name == readonlyAttr) {
     if (oldValue.isNull() != value.isNull()) {
       setNeedsWillValidateCheck();
       pseudoStateChanged(CSSSelector::PseudoReadOnly);
       pseudoStateChanged(CSSSelector::PseudoReadWrite);
       if (layoutObject())
         LayoutTheme::theme().controlStateChanged(*layoutObject(),
                                                  ReadOnlyControlState);
     }
   } else if (name == requiredAttr) {
     if (oldValue.isNull() != value.isNull())
       requiredAttributeChanged();
     UseCounter::count(document(), UseCounter::RequiredAttribute);
   } else if (name == autofocusAttr) {
     HTMLElement::parseAttribute(name, oldValue, value);
     UseCounter::count(document(), UseCounter::AutoFocusAttribute);
   } else {
     HTMLElement::parseAttribute(name, oldValue, value);
   }
 }
 
 void HTMLFormControlElement::disabledAttributeChanged() {
+  // Don't blur in this function because this is called for descendants of
+  // <fieldset> while tree traversal.
+  EventDispatchForbiddenScope eventForbidden;
+
   setNeedsWillValidateCheck();
   pseudoStateChanged(CSSSelector::PseudoDisabled);
   pseudoStateChanged(CSSSelector::PseudoEnabled);
   if (layoutObject())
     LayoutTheme::theme().controlStateChanged(*layoutObject(),
                                              EnabledControlState);
-  if (isDisabledFormControl() && adjustedFocusedElementInTreeScope() == this) {
-    // We might want to call blur(), but it's dangerous to dispatch events
-    // here.
-    document().setNeedsFocusedElementCheck();
-  }
 }
 
 void HTMLFormControlElement::requiredAttributeChanged() {
   setNeedsValidityCheck();
   pseudoStateChanged(CSSSelector::PseudoRequired);
   pseudoStateChanged(CSSSelector::PseudoOptional);
 }
 
 bool HTMLFormControlElement::isReadOnly() const {
   return fastHasAttribute(HTMLNames::readonlyAttr);
@@ skipping 435 matching lines @@
     const Element& source) {
   HTMLElement::copyNonAttributePropertiesFromElement(source);
   setNeedsValidityCheck();
 }
 
 void HTMLFormControlElement::associateWith(HTMLFormElement* form) {
   associateByParser(form);
 };
 
 }  // namespace blink