[WIP] Use the flat tree for hover handling.

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 2011 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 466 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 1380 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();
 }
 
 void Document::hoveredNodeDetached(Element& element) {
-  if (!m_hoverNode)
+  if (!m_hoverElement)
     return;
 
-  m_hoverNode->updateDistribution();
-  if (element != m_hoverNode &&
-      (!m_hoverNode->isTextNode() ||
-       element != FlatTreeTraversal::parent(*m_hoverNode)))
+  m_hoverElement->updateDistribution();
+  if (element != m_hoverElement)
     return;
 
-  m_hoverNode = FlatTreeTraversal::parent(element);
-  while (m_hoverNode && !m_hoverNode->layoutObject())
-    m_hoverNode = FlatTreeTraversal::parent(*m_hoverNode);
+  m_hoverElement = FlatTreeTraversal::parentElement(element);
+  while (m_hoverElement &&
+         !(m_hoverElement->layoutObject() && m_hoverElement->isHovered()))
+    m_hoverElement = FlatTreeTraversal::parentElement(*m_hoverElement);
 
   // 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();
 }
@@ skipping 2168 matching lines @@
       !m_snapCoordinator)
     m_snapCoordinator = SnapCoordinator::create();
 
   return m_snapCoordinator.get();
 }
 
 void Document::setContextFeatures(ContextFeatures& features) {
   m_contextFeatures = &features;
 }
 
-static LayoutObject* nearestCommonHoverAncestor(LayoutObject* obj1,
-                                                LayoutObject* obj2) {
-  if (!obj1 || !obj2)
-    return 0;
-
-  for (LayoutObject* currObj1 = obj1; currObj1;
-       currObj1 = currObj1->hoverAncestor()) {
-    for (LayoutObject* currObj2 = obj2; currObj2;
-         currObj2 = currObj2->hoverAncestor()) {
-      if (currObj1 == currObj2)
-        return currObj1;
-    }
-  }
-
-  return 0;
-}
-
 // TODO(mustaq) |request| parameter maybe a misuse of HitTestRequest in
 // updateHoverActiveState() since the function doesn't bother with hit-testing.
 void Document::updateHoverActiveState(const HitTestRequest& request,
                                       Element* innerElement,
                                       Scrollbar* hitScrollbar) {
   DCHECK(!request.readOnly());
 
   if (request.active() && m_frame)
     m_frame->eventHandler().notifyElementActivated();
 
@@ skipping 42 matching lines @@
         m_userActionElements.setInActiveChain(node, 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.
+  // changes in :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();
 
   // Check to see if the hovered node has changed.
   // If it hasn't, we do not need to do anything.
-  Node* newHoverNode = innerElementInDocument;
-  while (newHoverNode && !newHoverNode->layoutObject())
-    newHoverNode = newHoverNode->parentOrShadowHostNode();
+  Element* newHoverElement = innerElementInDocument;
+  while (newHoverElement && !newHoverElement->layoutObject()) {
+    newHoverElement =
+        LayoutTreeBuilderTraversal::parentElement(*newHoverElement);
+  }
+
+  DCHECK(!oldHoverElement || oldHoverElement->isConnected());
+  DCHECK(!oldHoverElement || oldHoverElement->isHovered());
 
   // Update our current hover node.
-  setHoverNode(newHoverNode);
+  setHoverElement(newHoverElement);
 
-  // We have two different objects. Fetch their layoutObjects.
-  LayoutObject* oldHoverObj =
-      oldHoverNode ? oldHoverNode->layoutObject() : nullptr;
-  LayoutObject* newHoverObj =
-      newHoverNode ? newHoverNode->layoutObject() : nullptr;
+  Node* ancestor = (oldHoverElement && newHoverElement)
+                       ? FlatTreeTraversal::commonAncestor(*oldHoverElement,
+                                                           *newHoverElement)
+                       : nullptr;
 
-  // Locate the common ancestor layout object for the two layoutObjects.
-  LayoutObject* ancestor = nearestCommonHoverAncestor(oldHoverObj, newHoverObj);
-  Node* ancestorNode(ancestor ? ancestor->node() : nullptr);
+  HeapVector<Member<Element>, 32> elementsToRemoveFromChain;
+  HeapVector<Member<Element>, 32> elementsToAddToChain;
 
-  HeapVector<Member<Node>, 32> nodesToRemoveFromChain;
-  HeapVector<Member<Node>, 32> nodesToAddToChain;
-
-  if (oldHoverObj != newHoverObj) {
-    // If the old hovered node is not nil but it's layoutObject is, it was
-    // probably detached as part of the :hover style (for instance by setting
-    // display:none in the :hover pseudo-class). In this case, the old hovered
-    // element (and its ancestors) must be updated, to ensure it's normal style
-    // is re-applied.
-    if (oldHoverNode && !oldHoverObj) {
-      for (Node& node : NodeTraversal::inclusiveAncestorsOf(*oldHoverNode)) {
-        if (!mustBeInActiveChain ||
-            (node.isElementNode() && toElement(node).inActiveChain()))
-          nodesToRemoveFromChain.push_back(node);
-      }
-    }
-
+  if (oldHoverElement != newHoverElement) {
     // The old hover path only needs to be cleared up to (and not including) the
     // common ancestor;
-    for (LayoutObject* curr = oldHoverObj; curr && curr != ancestor;
-         curr = curr->hoverAncestor()) {
-      if (curr->node() && !curr->isText() &&
-          (!mustBeInActiveChain || curr->node()->inActiveChain()))
-        nodesToRemoveFromChain.push_back(curr->node());
-    }
-
-    // TODO(mustaq): The two loops above may push a single node twice into
-    // nodesToRemoveFromChain. There must be a better way.
+    for (Element* curr = oldHoverElement; curr && curr != ancestor;
+         curr = FlatTreeTraversal::parentElement(*curr))
+      elementsToRemoveFromChain.push_back(curr);
   }
 
   // Now set the hover state for our new object up to the root.
-  for (LayoutObject* curr = newHoverObj; curr; curr = curr->hoverAncestor()) {
-    if (curr->node() && !curr->isText() &&
-        (!mustBeInActiveChain || curr->node()->inActiveChain()))
-      nodesToAddToChain.push_back(curr->node());
-  }
+  for (Element* curr = newHoverElement; curr;
+       curr = FlatTreeTraversal::parentElement(*curr))
+    elementsToAddToChain.push_back(curr);
 
-  size_t removeCount = nodesToRemoveFromChain.size();
-  for (size_t i = 0; i < removeCount; ++i) {
-    nodesToRemoveFromChain[i]->setHovered(false);
-  }
+  for (Element* element : elementsToRemoveFromChain)
+    element->setHovered(false);
 
   bool sawCommonAncestor = false;
-  size_t addCount = nodesToAddToChain.size();
-  for (size_t i = 0; i < addCount; ++i) {
+  for (Element* element : elementsToAddToChain) {
     // Elements past the common ancestor do not change hover state, but might
     // change active state.
-    if (ancestorNode && nodesToAddToChain[i] == ancestorNode)
+    if (element == ancestor)
       sawCommonAncestor = true;
-    if (allowActiveChanges)
-      nodesToAddToChain[i]->setActive(true);
-    if (!sawCommonAncestor || nodesToAddToChain[i] == m_hoverNode) {
-      nodesToAddToChain[i]->setHovered(true);
-    }
+    if (allowActiveChanges &&
+        (!mustBeInActiveChain || element->inActiveChain()))
+      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