Update hover states when dragging the mouse into 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 2612 matching lines @@
 
   if (layout_view_)
     layout_view_->SetIsInWindow(false);
 
   if (RegistrationContext())
     RegistrationContext()->DocumentWasDetached();
 
   MutationObserver::CleanSlotChangeList(*this);
 
   hover_element_ = nullptr;
-  active_hover_element_ = nullptr;
+  active_element_ = nullptr;
   autofocus_element_ = nullptr;
 
   if (focused_element_.Get()) {
     Element* old_focused_element = focused_element_;
     focused_element_ = nullptr;
     if (GetPage())
       GetPage()->GetChromeClient().FocusedNodeChanged(old_focused_element,
                                                       nullptr);
   }
   sequential_focus_navigation_starting_point_ = nullptr;
@@ skipping 1536 matching lines @@
     DCHECK(!GetLayoutViewItem().IsNull() || ImportsController());
     if (!GetLayoutViewItem().IsNull())
       GetLayoutViewItem().InvalidatePaintForViewAndCompositedLayers();
   }
 }
 
 void Document::SetHoverElement(Element* new_hover_element) {
   hover_element_ = new_hover_element;
 }
 
-void Document::SetActiveHoverElement(Element* new_active_element) {
+void Document::SetActiveElement(Element* new_active_element) {
   if (!new_active_element) {
-    active_hover_element_.Clear();
+    active_element_.Clear();
     return;
   }
 
-  active_hover_element_ = new_active_element;
+  active_element_ = new_active_element;
 }
 
 void Document::RemoveFocusedElementOfSubtree(Node* node,
                                              bool among_children_only) {
   if (!focused_element_)
     return;
 
   // We can't be focused if we're not in the document.
   if (!node->isConnected())
     return;
@@ skipping 24 matching lines @@
   // hover effects on the ancestors of |element| and do not invoke
   // new hover effects on any other element.
   if (!GetPage()->IsCursorVisible())
     return;
 
   if (GetFrame())
     GetFrame()->GetEventHandler().ScheduleHoverStateUpdate();
 }
 
 void Document::ActiveChainNodeDetached(Element& element) {
-  if (element == active_hover_element_)
-    active_hover_element_ = SkipDisplayNoneAncestors(&element);
+  if (element == active_element_)
+    active_element_ = SkipDisplayNoneAncestors(&element);
 }
 
 const Vector<AnnotatedRegionValue>& Document::AnnotatedRegions() const {
   return annotated_regions_;
 }
 
 void Document::SetAnnotatedRegions(
     const Vector<AnnotatedRegionValue>& regions) {
   annotated_regions_ = regions;
   SetAnnotatedRegionsDirty(false);
@@ skipping 2211 matching lines @@
 
   while (inner_element_in_document &&
          inner_element_in_document->GetDocument() != this) {
     inner_element_in_document->GetDocument().UpdateHoverActiveState(
         request, inner_element_in_document);
     inner_element_in_document =
         inner_element_in_document->GetDocument().LocalOwner();
   }
 
   UpdateDistribution();
-  Element* old_active_element = ActiveHoverElement();
+
+  UpdateActiveState(request, inner_element_in_document);
+  UpdateHoverState(request, inner_element_in_document);
+}
+
+void Document::UpdateActiveState(const HitTestRequest& request,
+                                 Element* inner_element_in_document) {
+  Element* old_active_element = GetActiveElement();
   if (old_active_element && !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 (Element* element = old_active_element; element;
          element = FlatTreeTraversal::ParentElement(*element)) {
       element->SetActive(false);
       user_action_elements_.SetInActiveChain(element, false);
     }
-    SetActiveHoverElement(nullptr);
+    SetActiveElement(nullptr);
   } else {
     Element* new_active_element = inner_element_in_document;
     if (!old_active_element && new_active_element &&
         !new_active_element->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 (Element* element = new_active_element; element;
            element = FlatTreeTraversal::ParentElement(*element)) {
         user_action_elements_.SetInActiveChain(element, true);
       }
-      SetActiveHoverElement(new_active_element);
+      SetActiveElement(new_active_element);
     }
   }
 
+  // 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 allow_active_changes = !old_active_element && GetActiveElement();
+  if (!allow_active_changes)
+    return;
+
+  // If the mouse is down and if this is a mouse move event, we want to restrict
+  // 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 must_be_in_active_chain = request.Active() && request.Move();
+
+  Element* new_element =
+      SkipDisplayNoneAncestors(inner_element_in_document);
+
+  // Now set the active state for our new object up to the root.
+  for (Element* curr = new_element; curr;
+       curr = FlatTreeTraversal::ParentElement(*curr)) {
+    if (!must_be_in_active_chain || curr->InActiveChain())
+      curr->SetActive(true);
+  }
+}
+
+void Document::UpdateHoverState(const HitTestRequest& request,
+                                Element* inner_element_in_document) {
   // Do not set hover state if event is from touch and on mobile.
   bool allow_hover_changes =
       !(request.TouchEvent() && GetPage() &&
         GetPage()->GetVisualViewport().ShouldDisableDesktopWorkarounds());
 
-  // 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 allow_active_changes = !old_active_element && 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 must_be_in_active_chain = request.Active() && request.Move();
-
   Element* old_hover_element = 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.
   Element* new_hover_element =
       SkipDisplayNoneAncestors(inner_element_in_document);
 
   // Update our current hover element.
   if (allow_hover_changes)
     SetHoverElement(new_hover_element);
 
+  if (old_hover_element == new_hover_element || !allow_hover_changes)
+    return;
+
   Node* ancestor_element = nullptr;
   if (old_hover_element && old_hover_element->isConnected() &&
       new_hover_element) {
     Node* ancestor = FlatTreeTraversal::CommonAncestor(*old_hover_element,
                                                        *new_hover_element);
     if (ancestor && ancestor->IsElementNode())
       ancestor_element = ToElement(ancestor);
   }
 
   HeapVector<Member<Element>, 32> elements_to_remove_from_chain;
-  HeapVector<Member<Element>, 32> elements_to_add_to_chain;
+  HeapVector<Member<Element>, 32> elements_to_add_to_hover_chain;
 
-  if (old_hover_element != new_hover_element) {
-    // The old hover path only needs to be cleared up to (and not including) the
-    // common ancestor;
-    //
-    // 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 (old_hover_element && old_hover_element->isConnected()) {
-      for (Element* curr = old_hover_element; curr && curr != ancestor_element;
-           curr = FlatTreeTraversal::ParentElement(*curr)) {
-        if (!must_be_in_active_chain || curr->InActiveChain())
-          elements_to_remove_from_chain.push_back(curr);
-      }
+  // The old hover path only needs to be cleared up to (and not including) the
+  // common ancestor;
+  //
+  // FIXME(ecobos@igalia.com): oldHoverElement may be disconnected from the
+  // tree already.
+  if (old_hover_element && old_hover_element->isConnected()) {
+    for (Element* curr = old_hover_element; curr && curr != ancestor_element;
+         curr = FlatTreeTraversal::ParentElement(*curr)) {
+      elements_to_remove_from_chain.push_back(curr);
     }
   }
 
   // Now set the hover state for our new object up to the root.
   for (Element* curr = new_hover_element; curr;
        curr = FlatTreeTraversal::ParentElement(*curr)) {
-    if (!must_be_in_active_chain || curr->InActiveChain())
-      elements_to_add_to_chain.push_back(curr);
+    elements_to_add_to_hover_chain.push_back(curr);
   }
 
-  if (allow_hover_changes) {
-    for (Element* element : elements_to_remove_from_chain)
-      element->SetHovered(false);
-  }
+  for (Element* element : elements_to_remove_from_chain)
+    element->SetHovered(false);
 
   bool saw_common_ancestor = false;
-  for (Element* element : elements_to_add_to_chain) {
-    // Elements past the common ancestor do not change hover state, but might
-    // change active state.
+  for (Element* element : elements_to_add_to_hover_chain) {
     if (element == ancestor_element)
       saw_common_ancestor = true;
-    if (allow_active_changes)
-      element->SetActive(true);
-    if (allow_hover_changes &&
-        (!saw_common_ancestor || element == hover_element_))
+    if (!saw_common_ancestor || element == hover_element_)
       element->SetHovered(true);
   }
 }
 
 bool Document::HaveScriptBlockingStylesheetsLoaded() const {
   return style_engine_->HaveScriptBlockingStylesheetsLoaded();
 }
 
 bool Document::HaveRenderBlockingStylesheetsLoaded() const {
   if (RuntimeEnabledFeatures::CSSInBodyDoesNotBlockPaintEnabled())
@@ skipping 241 matching lines @@
 }
 
 DEFINE_TRACE(Document) {
   visitor->Trace(imports_controller_);
   visitor->Trace(doc_type_);
   visitor->Trace(implementation_);
   visitor->Trace(autofocus_element_);
   visitor->Trace(focused_element_);
   visitor->Trace(sequential_focus_navigation_starting_point_);
   visitor->Trace(hover_element_);
-  visitor->Trace(active_hover_element_);
+  visitor->Trace(active_element_);
   visitor->Trace(document_element_);
   visitor->Trace(root_scroller_controller_);
   visitor->Trace(title_element_);
   visitor->Trace(ax_object_cache_);
   visitor->Trace(markers_);
   visitor->Trace(css_target_);
   visitor->Trace(current_script_stack_);
   visitor->Trace(script_runner_);
   visitor->Trace(lists_invalidated_at_document_);
   for (int i = 0; i < kNumNodeListInvalidationTypes; ++i)
@@ skipping 86 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