Document::hoverNode() is always an Element.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 2009 matching lines @@
   // SecurityOrigin.
 
   updateStyle();
 
   notifyLayoutTreeOfSubtreeChanges();
 
   // As a result of the style recalculation, the currently hovered element might
   // have been detached (for example, by setting display:none in the :hover
   // style), schedule another mouseMove event to check if any other elements
   // ended up under the mouse pointer due to re-layout.
-  if (hoverNode() && !hoverNode()->layoutObject() && frame())
+  if (hoverElement() && !hoverElement()->layoutObject() && frame())
     frame()->eventHandler().dispatchFakeMouseMoveEventSoon();
 
   if (m_focusedElement && !m_focusedElement->isFocusable())
     clearFocusedElementSoon();
   layoutViewItem().clearHitTestCache();
 
   DCHECK(!DocumentAnimations::needsAnimationTimingUpdate(*this));
 
   unsigned elementCount =
       styleEngine().styleForElementCount() - startElementCount;
@@ skipping 469 matching lines @@
     m_domWindow->clearEventQueue();
 
   if (m_layoutView)
     m_layoutView->setIsInWindow(false);
 
   if (registrationContext())
     registrationContext()->documentWasDetached();
 
   MutationObserver::cleanSlotChangeList(*this);
 
-  m_hoverNode = nullptr;
+  m_hoverElement = nullptr;
   m_activeHoverElement = nullptr;
   m_autofocusElement = nullptr;
 
   if (m_focusedElement.get()) {
     Element* oldFocusedElement = m_focusedElement;
     m_focusedElement = nullptr;
     if (page())
       page()->chromeClient().focusedNodeChanged(oldFocusedElement, nullptr);
   }
   m_sequentialFocusNavigationStartingPoint = nullptr;
@@ skipping 1382 matching lines @@
     // We need to manually repaint because we avoid doing all repaints in layout
     // or style recalc while sheets are still loading to avoid FOUC.
     m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
 
     DCHECK(!layoutViewItem().isNull() || importsController());
     if (!layoutViewItem().isNull())
       layoutViewItem().invalidatePaintForViewAndCompositedLayers();
   }
 }
 
-void Document::setHoverNode(Node* newHoverNode) {
-  m_hoverNode = newHoverNode;
+void Document::setHoverElement(Element* newHoverElement) {
+  m_hoverElement = newHoverElement;
 }
 
 void Document::setActiveHoverElement(Element* newActiveElement) {
   if (!newActiveElement) {
     m_activeHoverElement.clear();
     return;
   }
 
   m_activeHoverElement = newActiveElement;
 }
 
 void Document::removeFocusedElementOfSubtree(Node* node,
                                              bool amongChildrenOnly) {
   if (!m_focusedElement)
     return;
 
   // We can't be focused if we're not in the document.
   if (!node->isConnected())
     return;
   bool contains =
       node->isShadowIncludingInclusiveAncestorOf(m_focusedElement.get());
   if (contains && (m_focusedElement != node || !amongChildrenOnly))
     clearFocusedElement();
 }
 
-static Node* skipDisplayNoneAncestors(Node* node) {
-  while (node) {
-    if (node->layoutObject())
-      return node;
-    if (node->isElementNode() && toElement(node)->hasDisplayContentsStyle())
-      return node;
-    node = FlatTreeTraversal::parent(*node);
+static Element* skipDisplayNoneAncestors(Element* element) {
+  for (; element; element = FlatTreeTraversal::parentElement(*element)) {
+    if (element->layoutObject() || element->hasDisplayContentsStyle())
+      return element;
   }
   return nullptr;
 }
 
-void Document::hoveredNodeDetached(Element& element) {
-  if (!m_hoverNode)
+void Document::hoveredElementDetached(Element& element) {
+  if (!m_hoverElement)
+    return;
+  if (element != m_hoverElement)
     return;
 
-  m_hoverNode->updateDistribution();
-  if (element != m_hoverNode &&
-      (!m_hoverNode->isTextNode() ||
-       element != FlatTreeTraversal::parent(*m_hoverNode)))
-    return;
-
-  m_hoverNode = skipDisplayNoneAncestors(&element);
+  m_hoverElement->updateDistribution();
+  m_hoverElement = skipDisplayNoneAncestors(&element);
 
   // If the mouse cursor is not visible, do not clear existing
   // hover effects on the ancestors of |element| and do not invoke
   // new hover effects on any other element.
   if (!page()->isCursorVisible())
     return;
 
   if (frame())
     frame()->eventHandler().scheduleHoverStateUpdate();
 }
 
 void Document::activeChainNodeDetached(Element& element) {
-  if (!m_activeHoverElement)
-    return;
-
-  if (element != m_activeHoverElement)
-    return;
-
-  Node* activeNode = skipDisplayNoneAncestors(&element);
-  m_activeHoverElement = activeNode && activeNode->isElementNode()
-                             ? toElement(activeNode)
-                             : nullptr;
+  if (element == m_activeHoverElement)
+    m_activeHoverElement = skipDisplayNoneAncestors(&element);
 }
 
 const Vector<AnnotatedRegionValue>& Document::annotatedRegions() const {
   return m_annotatedRegions;
 }
 
 void Document::setAnnotatedRegions(
     const Vector<AnnotatedRegionValue>& regions) {
   m_annotatedRegions = regions;
   setAnnotatedRegionsDirty(false);
@@ skipping 2171 matching lines @@
         request, innerElementInDocument);
     innerElementInDocument = innerElementInDocument->document().localOwner();
   }
 
   updateDistribution();
   Element* oldActiveElement = activeHoverElement();
   if (oldActiveElement && !request.active()) {
     // The oldActiveElement layoutObject is null, dropped on :active by setting
     // display: none, for instance. We still need to clear the ActiveChain as
     // the mouse is released.
-    for (Node* node = oldActiveElement; node;
-         node = FlatTreeTraversal::parent(*node)) {
-      DCHECK(!node->isTextNode());
-      node->setActive(false);
-      m_userActionElements.setInActiveChain(node, false);
+    for (Element* element = oldActiveElement; element;
+         element = FlatTreeTraversal::parentElement(*element)) {
+      element->setActive(false);
+      m_userActionElements.setInActiveChain(element, false);
     }
     setActiveHoverElement(nullptr);
   } else {
     Element* newActiveElement = innerElementInDocument;
     if (!oldActiveElement && newActiveElement &&
         !newActiveElement->isDisabledFormControl() && request.active() &&
         !request.touchMove()) {
       // We are setting the :active chain and freezing it. If future moves
       // happen, they will need to reference this chain.
-      for (Node* node = newActiveElement; node;
-           node = FlatTreeTraversal::parent(*node)) {
-        DCHECK(!node->isTextNode());
-        m_userActionElements.setInActiveChain(node, true);
+      for (Element* element = newActiveElement; element;
+           element = FlatTreeTraversal::parentElement(*element)) {
+        m_userActionElements.setInActiveChain(element, true);
       }
       setActiveHoverElement(newActiveElement);
     }
   }
   // If the mouse has just been pressed, set :active on the chain. Those (and
   // only those) nodes should remain :active until the mouse is released.
   bool allowActiveChanges = !oldActiveElement && activeHoverElement();
 
   // If the mouse is down and if this is a mouse move event, we want to restrict
   // changes in :hover/:active to only apply to elements that are in the :active
   // chain that we froze at the time the mouse went down.
   bool mustBeInActiveChain = request.active() && request.move();
 
-  Node* oldHoverNode = hoverNode();
+  Element* oldHoverElement = hoverElement();
 
   // The passed in innerElement may not be a result of a hit test for the
   // current up-to-date flat/layout tree. That means the element may be
   // display:none at this point. Skip up the ancestor chain until we reach an
   // element with a layoutObject or a display:contents element.
-  Node* newHoverNode = skipDisplayNoneAncestors(innerElementInDocument);
+  Element* newHoverElement = skipDisplayNoneAncestors(innerElementInDocument);
 
-  // Update our current hover node.
-  setHoverNode(newHoverNode);
+  // Update our current hover element.
+  setHoverElement(newHoverElement);
 
-  Node* ancestor =
-      (oldHoverNode && oldHoverNode->isConnected() && newHoverNode)
-          ? FlatTreeTraversal::commonAncestor(*oldHoverNode, *newHoverNode)
-          : nullptr;
+  Node* ancestorElement = nullptr;
+  if (oldHoverElement && oldHoverElement->isConnected() && newHoverElement) {
+    Node* ancestor =
+        FlatTreeTraversal::commonAncestor(*oldHoverElement, *newHoverElement);
+    if (ancestor && ancestor->isElementNode())
+      ancestorElement = toElement(ancestor);
+  }
 
-  HeapVector<Member<Node>, 32> nodesToRemoveFromChain;
-  HeapVector<Member<Node>, 32> nodesToAddToChain;
+  HeapVector<Member<Element>, 32> elementsToRemoveFromChain;
+  HeapVector<Member<Element>, 32> elementsToAddToChain;
 
-  if (oldHoverNode != newHoverNode) {
+  if (oldHoverElement != newHoverElement) {
     // The old hover path only needs to be cleared up to (and not including) the
     // common ancestor;
     //
-    // FIXME(ecobos@igalia.com): oldHoverNode may be disconnected from the tree
-    // already. This is due to our handling of m_hoverNode in
-    // hoveredNodeDetached (which assumes all the parents are hovered) and
+    // FIXME(ecobos@igalia.com): oldHoverElement may be disconnected from the
+    // tree already. This is due to our handling of m_hoverElement in
+    // hoveredElementDetached (which assumes all the parents are hovered) and
     // mustBeInActiveChain (which makes this not hold).
     //
     // In that case, none of the nodes in the chain have the flags, so there's
     // no problem in skipping this step.
-    if (oldHoverNode && oldHoverNode->isConnected()) {
-      for (Node* curr = oldHoverNode; curr && curr != ancestor;
-           curr = FlatTreeTraversal::parent(*curr)) {
-        if (!curr->isTextNode() &&
-            (!mustBeInActiveChain || curr->inActiveChain()))
-          nodesToRemoveFromChain.push_back(curr);
+    if (oldHoverElement && oldHoverElement->isConnected()) {
+      for (Element* curr = oldHoverElement; curr && curr != ancestorElement;
+           curr = FlatTreeTraversal::parentElement(*curr)) {
+        if (!mustBeInActiveChain || curr->inActiveChain())
+          elementsToRemoveFromChain.push_back(curr);
       }
     }
   }
 
   // Now set the hover state for our new object up to the root.
-  for (Node* curr = newHoverNode; curr;
-       curr = FlatTreeTraversal::parent(*curr)) {
-    if (!curr->isTextNode() && (!mustBeInActiveChain || curr->inActiveChain()))
-      nodesToAddToChain.push_back(curr);
+  for (Element* curr = newHoverElement; curr;
+       curr = FlatTreeTraversal::parentElement(*curr)) {
+    if (!mustBeInActiveChain || curr->inActiveChain())
+      elementsToAddToChain.push_back(curr);
   }
 
-  for (Node* node : nodesToRemoveFromChain)
-    node->setHovered(false);
+  for (Element* element : elementsToRemoveFromChain)
+    element->setHovered(false);
 
   bool sawCommonAncestor = false;
-  for (Node* node : nodesToAddToChain) {
+  for (Element* element : elementsToAddToChain) {
     // Elements past the common ancestor do not change hover state, but might
     // change active state.
-    if (node == ancestor)
+    if (element == ancestorElement)
       sawCommonAncestor = true;
     if (allowActiveChanges)
-      node->setActive(true);
-    if (!sawCommonAncestor || node == m_hoverNode)
-      node->setHovered(true);
+      element->setActive(true);
+    if (!sawCommonAncestor || element == m_hoverElement)
+      element->setHovered(true);
   }
 }
 
 bool Document::haveScriptBlockingStylesheetsLoaded() const {
   return m_styleEngine->haveScriptBlockingStylesheetsLoaded();
 }
 
 bool Document::haveRenderBlockingStylesheetsLoaded() const {
   if (RuntimeEnabledFeatures::cssInBodyDoesNotBlockPaintEnabled())
     return m_styleEngine->haveRenderBlockingStylesheetsLoaded();
@@ skipping 234 matching lines @@
   sendSensitiveInputVisibility();
 }
 
 DEFINE_TRACE(Document) {
   visitor->trace(m_importsController);
   visitor->trace(m_docType);
   visitor->trace(m_implementation);
   visitor->trace(m_autofocusElement);
   visitor->trace(m_focusedElement);
   visitor->trace(m_sequentialFocusNavigationStartingPoint);
-  visitor->trace(m_hoverNode);
+  visitor->trace(m_hoverElement);
   visitor->trace(m_activeHoverElement);
   visitor->trace(m_documentElement);
   visitor->trace(m_rootScrollerController);
   visitor->trace(m_titleElement);
   visitor->trace(m_axObjectCache);
   visitor->trace(m_markers);
   visitor->trace(m_cssTarget);
   visitor->trace(m_currentScriptStack);
   visitor->trace(m_scriptRunner);
   visitor->trace(m_listsInvalidatedAtDocument);
@@ skipping 92 matching lines @@
 }
 
 void showLiveDocumentInstances() {
   WeakDocumentSet& set = liveDocumentSet();
   fprintf(stderr, "There are %u documents currently alive:\n", set.size());
   for (blink::Document* document : set)
     fprintf(stderr, "- Document %p URL: %s\n", document,
             document->url().getString().utf8().data());
 }
 #endif