Merge two IsInDocument implementations.

third_party/WebKit/Source/core/input/BoundaryEventDispatcher.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/input/BoundaryEventDispatcher.h"
 
 #include "core/dom/Node.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
+#include "core/input/EventHandlingUtil.h"
 
 namespace blink {
 
 namespace {
 
-bool IsInDocument(EventTarget* target) {
-  return target && target->ToNode() && target->ToNode()->isConnected();
-}
-
 void BuildAncestorChain(EventTarget* target,
                         HeapVector<Member<Node>, 20>* ancestors) {
-  if (!IsInDocument(target))
+  if (!EventHandlingUtil::IsInDocument(target))
     return;
   Node* target_node = target->ToNode();
   DCHECK(target_node);
   target_node->UpdateDistribution();
   // Index 0 element in the ancestors arrays will be the corresponding
   // target. So the root of their document will be their last element.
   for (Node* node = target_node; node; node = FlatTreeTraversal::Parent(*node))
     ancestors->push_back(node);
 }
 
@@ skipping 27 matching lines @@
 }
 
 }  // namespace
 
 void BoundaryEventDispatcher::SendBoundaryEvents(EventTarget* exited_target,
                                                  EventTarget* entered_target) {
   if (exited_target == entered_target)
     return;
 
   // Dispatch out event
-  if (IsInDocument(exited_target))
+  if (EventHandlingUtil::IsInDocument(exited_target))
     DispatchOut(exited_target, entered_target);
 
   // Create lists of all exited/entered ancestors, locate the common ancestor
   // Based on httparchive, in more than 97% cases the depth of DOM is less
   // than 20.
   HeapVector<Member<Node>, 20> exited_ancestors;
   HeapVector<Member<Node>, 20> entered_ancestors;
   size_t exited_ancestors_common_parent_index = 0;
   size_t entered_ancestors_common_parent_index = 0;
 
@@ skipping 29 matching lines @@
       break;
     }
   }
 
   // Dispatch leave events, in child-to-parent order.
   for (size_t j = 0; j < exited_ancestors_common_parent_index; j++)
     DispatchLeave(exited_ancestors[j], entered_target,
                   !exited_node_has_capturing_ancestor);
 
   // Dispatch over event
-  if (IsInDocument(entered_target))
+  if (EventHandlingUtil::IsInDocument(entered_target))
     DispatchOver(entered_target, exited_target);
 
   // Defer locating capturing enter listener until /after/ dispatching the leave
   // events because the leave handlers might set a capturing enter handler.
   bool entered_node_has_capturing_ancestor = false;
   const AtomicString& enter_event = GetEnterEvent();
   for (size_t i = 0; i < entered_ancestors.size(); i++) {
     if (entered_ancestors[i]->HasCapturingEventListeners(enter_event)) {
       entered_node_has_capturing_ancestor = true;
       break;
     }
   }
 
   // Dispatch enter events, in parent-to-child order.
   for (size_t i = entered_ancestors_common_parent_index; i > 0; i--)
     DispatchEnter(entered_ancestors[i - 1], exited_target,
                   !entered_node_has_capturing_ancestor);
 }
 
 }  // namespace blink