Changeset 150715 in webkit

Timestamp:

May 26, 2013 7:29:15 AM (11 years ago)

Author:

akling@apple.com

Message:

Move "active" state logic from Node to Element.
<​http://webkit.org/b/116785>

Reviewed by Antti Koivisto.

Resolve another 7 year old FIXME by merging the "active" state logic from Node and ContainerNode
and moving it all to Element instead.

• dom/UserActionElementSet.h:

(WebCore::UserActionElementSet::isActive):
(WebCore::UserActionElementSet::setActive):

• dom/ContainerNode.cpp:
• dom/ContainerNode.h:
• dom/Node.cpp:
• dom/Node.h:
• dom/Element.h:

(WebCore::Element::active):

• dom/Element.cpp:

(WebCore::Element::isUserActionElementActive):
(WebCore::Element::setActive):

Moved here from Node/ContainerNode.

• accessibility/AccessibilityNodeObject.cpp:

(WebCore::AccessibilityNodeObject::isPressed):

• dom/Document.cpp:

(WebCore::Document::setFocusedNode):
(WebCore::Document::updateHoverActiveState):

• rendering/RenderTheme.cpp:

(WebCore::RenderTheme::isPressed):
(WebCore::RenderTheme::isSpinUpButtonPartPressed):

• rendering/RenderThemeMac.mm:

(WebCore::getMediaUIPartStateFlags):
(WebCore::RenderThemeMac::updatePressedState):

• platform/qt/RenderThemeQt.cpp:

(WebCore::RenderThemeQt::getMediaControlForegroundColor):

Check that the inspected Node is an Element before asking if it's active.

• html/HTMLAnchorElement.cpp:

(WebCore::HTMLAnchorElement::setActive):

Call the right superclass.

• html/HTMLAnchorElement.h:
• html/HTMLLabelElement.h:
• html/shadow/MediaControlElementTypes.h:

Sprinkle OVERRIDE>

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• accessibility/AccessibilityNodeObject.cpp (modified) (1 diff)
• dom/ContainerNode.cpp (modified) (1 diff)
• dom/ContainerNode.h (modified) (1 diff)
• dom/Document.cpp (modified) (3 diffs)
• dom/Element.cpp (modified) (4 diffs)
• dom/Element.h (modified) (2 diffs)
• dom/Node.cpp (modified) (1 diff)
• dom/Node.h (modified) (3 diffs)
• dom/UserActionElementSet.h (modified) (2 diffs)
• html/HTMLAnchorElement.cpp (modified) (1 diff)
• html/HTMLAnchorElement.h (modified) (1 diff)
• html/HTMLLabelElement.h (modified) (1 diff)
• html/shadow/MediaControlElementTypes.h (modified) (1 diff)
• platform/qt/RenderThemeQt.cpp (modified) (1 diff)
• rendering/RenderTheme.cpp (modified) (2 diffs)
• rendering/RenderThemeMac.mm (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-05-26  Andreas Kling  <akling@apple.com>
+
+        Move "active" state logic from Node to Element.
+        <http://webkit.org/b/116785>
+
+        Reviewed by Antti Koivisto.
+
+        Resolve another 7 year old FIXME by merging the "active" state logic from Node and ContainerNode
+        and moving it all to Element instead.
+
+        * dom/UserActionElementSet.h:
+        (WebCore::UserActionElementSet::isActive):
+        (WebCore::UserActionElementSet::setActive):
+        * dom/ContainerNode.cpp:
+        * dom/ContainerNode.h:
+        * dom/Node.cpp:
+        * dom/Node.h:
+        * dom/Element.h:
+        (WebCore::Element::active):
+        * dom/Element.cpp:
+        (WebCore::Element::isUserActionElementActive):
+        (WebCore::Element::setActive):
+
+            Moved here from Node/ContainerNode.
+
+        * accessibility/AccessibilityNodeObject.cpp:
+        (WebCore::AccessibilityNodeObject::isPressed):
+        * dom/Document.cpp:
+        (WebCore::Document::setFocusedNode):
+        (WebCore::Document::updateHoverActiveState):
+        * rendering/RenderTheme.cpp:
+        (WebCore::RenderTheme::isPressed):
+        (WebCore::RenderTheme::isSpinUpButtonPartPressed):
+        * rendering/RenderThemeMac.mm:
+        (WebCore::getMediaUIPartStateFlags):
+        (WebCore::RenderThemeMac::updatePressedState):
+        * platform/qt/RenderThemeQt.cpp:
+        (WebCore::RenderThemeQt::getMediaControlForegroundColor):
+
+            Check that the inspected Node is an Element before asking if it's active.
+
+        * html/HTMLAnchorElement.cpp:
+        (WebCore::HTMLAnchorElement::setActive):
+
+            Call the right superclass.
+
+        * html/HTMLAnchorElement.h:
+        * html/HTMLLabelElement.h:
+        * html/shadow/MediaControlElementTypes.h:
+
+            Sprinkle OVERRIDE>
+
 2013-05-26  Andreas Kling  <akling@apple.com>
 

trunk/Source/WebCore/accessibility/AccessibilityNodeObject.cpp

@@ -635 +635 @@
     }
 
-    return node->active();
+    if (!node->isElementNode())
+        return false;
+    return toElement(node)->active();
 }
 

trunk/Source/WebCore/dom/ContainerNode.cpp

@@ -969 +969 @@
 }
 
-void ContainerNode::setActive(bool down, bool pause)
-{
-    if (down == active()) return;
-
-    Node::setActive(down);
-
-    // note that we need to recalc the style
-    // FIXME: Move to Element
-    if (renderer()) {
-        bool reactsToPress = renderStyle()->affectedByActive() || (isElementNode() && toElement(this)->childrenAffectedByActive());
-        if (reactsToPress)
-            setNeedsStyleRecalc();
-        if (renderStyle()->hasAppearance()) {
-            if (renderer()->theme()->stateChanged(renderer(), PressedState))
-                reactsToPress = true;
-        }
-
-        // The rest of this function implements a feature that only works if the
-        // platform supports immediate invalidations on the ChromeClient, so bail if
-        // that isn't supported.
-        if (!document()->page()->chrome().client()->supportsImmediateInvalidation())
-            return;
-
-        if (reactsToPress && pause) {
-            // The delay here is subtle.  It relies on an assumption, namely that the amount of time it takes
-            // to repaint the "down" state of the control is about the same time as it would take to repaint the
-            // "up" state.  Once you assume this, you can just delay for 100ms - that time (assuming that after you
-            // leave this method, it will be about that long before the flush of the up state happens again).
-#ifdef HAVE_FUNC_USLEEP
-            double startTime = currentTime();
-#endif
-
-            // Ensure there are no pending changes
-            Document::updateStyleForAllDocuments();
-            // Do an immediate repaint.
-            if (renderer())
-                renderer()->repaint(true);
-
-            // FIXME: Find a substitute for usleep for Win32.
-            // Better yet, come up with a way of doing this that doesn't use this sort of thing at all.
-#ifdef HAVE_FUNC_USLEEP
-            // Now pause for a small amount of time (1/10th of a second from before we repainted in the pressed state)
-            double remainingTime = 0.1 - (currentTime() - startTime);
-            if (remainingTime > 0)
-                usleep(static_cast<useconds_t>(remainingTime * 1000000.0));
-#endif
-        }
-    }
-}
-
 unsigned ContainerNode::childNodeCount() const
 {

trunk/Source/WebCore/dom/ContainerNode.h

@@ -110 +110 @@
     virtual void detach() OVERRIDE;
     virtual LayoutRect boundingBox() const OVERRIDE;
-    virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
     virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE FINAL;
 

trunk/Source/WebCore/dom/Document.cpp

@@ -3341 +3341 @@
         ASSERT(!oldFocusedNode->inDetach());
 
-        if (oldFocusedNode->active())
-            oldFocusedNode->setActive(false);
-
-        if (oldFocusedNode->isElementNode())
+        if (oldFocusedNode->isElementNode()) {
+            Element* oldFocusedElement = toElement(oldFocusedNode.get());
+            if (oldFocusedElement->active())
+                oldFocusedElement->setActive(false);
+
             toElement(oldFocusedNode.get())->setFocus(false);
+        }
 
         // Dispatch a change event for form control elements that have been edited.
@@ -5871 +5873 @@
             if (curr->node()) {
                 ASSERT(!curr->node()->isTextNode());
-                curr->node()->setActive(false);
+                if (curr->node()->isElementNode())
+                    toElement(curr->node())->setActive(false);
                 m_userActionElements.setInActiveChain(curr->node(), false);
             }
@@ -5974 +5977 @@
     size_t addCount = nodesToAddToChain.size();
     for (size_t i = 0; i < addCount; ++i) {
-        if (allowActiveChanges)
-            nodesToAddToChain[i]->setActive(true);
+        if (allowActiveChanges && nodesToAddToChain[i]->isElementNode())
+            toElement(nodesToAddToChain[i].get())->setActive(true);
         if (ancestor && nodesToAddToChain[i] == ancestor->node())
             sawCommonAncestor = true;

trunk/Source/WebCore/dom/Element.cpp

@@ -31 +31 @@
 #include "CSSParser.h"
 #include "CSSSelectorList.h"
+#include "Chrome.h"
+#include "ChromeClient.h"
 #include "ClassList.h"
 #include "ClientRect.h"
@@ -87 +89 @@
 #include "htmlediting.h"
 #include <wtf/BitVector.h>
+#include <wtf/CurrentTime.h>
 #include <wtf/text/CString.h>
 
@@ -455 +458 @@
 }
 
+bool Element::isUserActionElementActive() const
+{
+    ASSERT(isUserActionElement());
+    return document()->userActionElements().isActive(this);
+}
+
 bool Element::isUserActionElementFocused() const
 {
@@ -465 +474 @@
     ASSERT(isUserActionElement());
     return document()->userActionElements().isHovered(this);
+}
+
+void Element::setActive(bool flag, bool pause)
+{
+    if (flag == active())
+        return;
+
+    if (Document* document = this->document())
+        document->userActionElements().setActive(this, flag);
+
+    if (!renderer())
+        return;
+
+    bool reactsToPress = renderStyle()->affectedByActive() || childrenAffectedByActive();
+    if (reactsToPress)
+        setNeedsStyleRecalc();
+
+    if (renderer()->style()->hasAppearance() && renderer()->theme()->stateChanged(renderer(), PressedState))
+        reactsToPress = true;
+
+    // The rest of this function implements a feature that only works if the
+    // platform supports immediate invalidations on the ChromeClient, so bail if
+    // that isn't supported.
+    if (!document()->page()->chrome().client()->supportsImmediateInvalidation())
+        return;
+
+    if (reactsToPress && pause) {
+        // The delay here is subtle. It relies on an assumption, namely that the amount of time it takes
+        // to repaint the "down" state of the control is about the same time as it would take to repaint the
+        // "up" state. Once you assume this, you can just delay for 100ms - that time (assuming that after you
+        // leave this method, it will be about that long before the flush of the up state happens again).
+#ifdef HAVE_FUNC_USLEEP
+        double startTime = currentTime();
+#endif
+
+        Document::updateStyleForAllDocuments();
+        // Do an immediate repaint.
+        if (renderer())
+            renderer()->repaint(true);
+
+        // FIXME: Come up with a less ridiculous way of doing this.
+#ifdef HAVE_FUNC_USLEEP
+        // Now pause for a small amount of time (1/10th of a second from before we repainted in the pressed state)
+        double remainingTime = 0.1 - (currentTime() - startTime);
+        if (remainingTime > 0)
+            usleep(static_cast<useconds_t>(remainingTime * 1000000.0));
+#endif
+    }
 }
 

trunk/Source/WebCore/dom/Element.h

@@ -427 +427 @@
     virtual const AtomicString& shadowPseudoId() const;
 
+    bool active() const { return isUserActionElement() && isUserActionElementActive(); }
     bool hovered() const { return isUserActionElement() && isUserActionElementHovered(); }
     bool focused() const { return isUserActionElement() && isUserActionElementFocused(); }
 
+    virtual void setActive(bool flag = true, bool pause = false);
     virtual void setHovered(bool flag = true);
     virtual void setFocus(bool flag);
@@ -663 +665 @@
 
 private:
+    bool isUserActionElementActive() const;
     bool isUserActionElementFocused() const;
     bool isUserActionElementHovered() const;

trunk/Source/WebCore/dom/Node.cpp

@@ -2678 +2678 @@
 }
 
-void Node::setActive(bool flag, bool)
-{
-    if (Document* document = this->document())
-        document->userActionElements().setActive(this, flag);
-}
-
-bool Node::isUserActionElementActive() const
-{
-    ASSERT(isUserActionElement());
-    return document()->userActionElements().isActive(this);
-}
-
 bool Node::isUserActionElementInActiveChain() const
 {

trunk/Source/WebCore/dom/Node.h

@@ -359 +359 @@
     void setUserActionElement(bool flag) { setFlag(flag, IsUserActionElement); }
 
-    bool active() const { return isUserActionElement() && isUserActionElementActive(); }
     bool inActiveChain() const { return isUserActionElement() && isUserActionElementInActiveChain(); }
 
@@ -397 +396 @@
     void lazyAttach(ShouldSetAttached = SetAttached);
     void lazyReattach(ShouldSetAttached = SetAttached);
-
-    virtual void setActive(bool flag = true, bool pause = false);
 
     enum UserSelectAllTreatment {
@@ -774 +771 @@
     bool isEditableToAccessibility(EditableLevel) const;
 
-    bool isUserActionElementActive() const;
     bool isUserActionElementInActiveChain() const;
-    bool isUserActionElementFocused() const;
 
     void setStyleChange(StyleChangeType);

trunk/Source/WebCore/dom/UserActionElementSet.h

@@ -1 +1 @@
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
+ * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44 +45 @@
 
     bool isFocused(const Element* element) { return hasFlags(element, IsFocusedFlag); }
-    bool isActive(const Node* node) { return hasFlags(node, IsActiveFlag); }
+    bool isActive(const Element* element) { return hasFlags(element, IsActiveFlag); }
     bool isInActiveChain(const Node* node) { return hasFlags(node, InActiveChainFlag); }
     bool isHovered(const Element* element) { return hasFlags(element, IsHoveredFlag); }
     void setFocused(Element* element, bool enable) { setFlags(element, enable, IsFocusedFlag); }
-    void setActive(Node* node, bool enable) { setFlags(node, enable, IsActiveFlag); }
+    void setActive(Element* element, bool enable) { setFlags(element, enable, IsActiveFlag); }
     void setInActiveChain(Node* node, bool enable) { setFlags(node, enable, InActiveChainFlag); }
     void setHovered(Element* element, bool enable) { setFlags(element, enable, IsHoveredFlag); }

trunk/Source/WebCore/html/HTMLAnchorElement.cpp

@@ -216 +216 @@
     }
     
-    ContainerNode::setActive(down, pause);
+    HTMLElement::setActive(down, pause);
 }
 

trunk/Source/WebCore/html/HTMLAnchorElement.h

@@ -113 +113 @@
     virtual bool isKeyboardFocusable(KeyboardEvent*) const OVERRIDE;
     virtual void defaultEventHandler(Event*);
-    virtual void setActive(bool active = true, bool pause = false);
+    virtual void setActive(bool active = true, bool pause = false) OVERRIDE FINAL;
     virtual void accessKeyAction(bool sendMouseEvents);
     virtual bool isURLAttribute(const Attribute&) const OVERRIDE;

trunk/Source/WebCore/html/HTMLLabelElement.h

@@ -47 +47 @@
 
     // Overridden to update the hover/active state of the corresponding control.
-    virtual void setActive(bool = true, bool pause = false);
+    virtual void setActive(bool = true, bool pause = false) OVERRIDE;
     virtual void setHovered(bool = true) OVERRIDE;
 

trunk/Source/WebCore/html/shadow/MediaControlElementTypes.h

@@ -170 +170 @@
 
 private:
-    void setActive(bool /*flag*/ = true, bool /*pause*/ = false);
+    void setActive(bool /*flag*/ = true, bool /*pause*/ = false) OVERRIDE FINAL;
 
     void startTimer();

trunk/Source/WebCore/platform/qt/RenderThemeQt.cpp

@@ -595 +595 @@
         return fgColor;
 
-    if (o->node()->active())
+    if (o->node() && o->node()->isElementNode() && toElement(o->node())->active())
         fgColor = fgColor.lighter();
 

trunk/Source/WebCore/rendering/RenderTheme.cpp

@@ -806 +806 @@
 bool RenderTheme::isPressed(const RenderObject* o) const
 {
-    if (!o->node())
-        return false;
-    return o->node()->active();
+    if (!o->node() || !o->node()->isElementNode())
+        return false;
+    return toElement(o->node())->active();
 }
 
@@ -814 +814 @@
 {
     Node* node = o->node();
-    if (!node || !node->active() || !node->isElementNode()
-        || !toElement(node)->isSpinButtonElement())
-        return false;
-    SpinButtonElement* element = static_cast<SpinButtonElement*>(node);
-    return element->upDownState() == SpinButtonElement::Up;
+    if (!node || !node->isElementNode())
+        return false;
+    Element* element = toElement(node);
+    if (!element->active() || !element->isSpinButtonElement())
+        return false;
+    return static_cast<SpinButtonElement*>(element)->upDownState() == SpinButtonElement::Up;
 }
 

trunk/Source/WebCore/rendering/RenderThemeMac.mm

@@ -253 +253 @@
     if (isDisabledFormControl(node))
         flags |= MediaUIPartDisabledFlag;
-    else if (node->active())
+    else if (node->isElementNode() && toElement(node)->active())
         flags |= MediaUIPartPressedFlag;
     return flags;
@@ -976 +976 @@
 {
     bool oldPressed = [cell isHighlighted];
-    bool pressed = (o->node() && o->node()->active());
+    bool pressed = o->node() && o->node()->isElementNode() && toElement(o->node())->active();
     if (pressed != oldPressed)
         [cell setHighlighted:pressed];