Make RenderedRectsForMarkers() to ignore disconnected nodes.

third_party/WebKit/Source/core/editing/EphemeralRange.cpp

 // Copyright 2015 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/editing/EphemeralRange.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Range.h"
 #include "core/dom/Text.h"
+#include "core/layout/LayoutObject.h"
+#include "core/layout/LayoutText.h"
 
 namespace blink {
 
 namespace {
 template <typename Strategy>
 Node* commonAncestorContainerNode(const Node* containerA,
                                   const Node* containerB) {
   if (!containerA || !containerB)
     return nullptr;
   return Strategy::commonAncestor(*containerA, *containerB);
@@ skipping 91 matching lines @@
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> EphemeralRangeTemplate<Strategy>::endPosition()
     const {
   DCHECK(isValid());
   return m_endPosition;
 }
 
 template <typename Strategy>
+IntRect EphemeralRangeTemplate<Strategy>::boundingBox() const {
+  IntRect result;
+  Vector<IntRect> rects;
+  textRects(rects);
+  for (const IntRect& rect : rects)
+    result.unite(rect);
+  return result;
+}
+
+template <typename Strategy>
+void EphemeralRangeTemplate<Strategy>::textRects(
+    Vector<IntRect>& rects,
+    bool useSelectionHeight) const {
+  Node* startContainer = m_startPosition.computeContainerNode();
+  DCHECK(startContainer);
+  Node* endContainer = m_endPosition.computeContainerNode();
+  DCHECK(endContainer);
+
+  for (Node& node : nodes()) {
+    LayoutObject* layoutObject = node.layoutObject();
+    if (!layoutObject || !layoutObject->isText())
+      continue;
+    LayoutText* layoutText = toLayoutText(layoutObject);
+    unsigned startOffset =
+        node == startContainer ? m_startPosition.offsetInContainerNode() : 0;
+    unsigned endOffset = node == endContainer
+                             ? m_endPosition.offsetInContainerNode()
+                             : std::numeric_limits<unsigned>::max();
+    layoutText->absoluteRectsForRange(rects, startOffset, endOffset,
+                                      useSelectionHeight);
+  }
+}
+
+template <typename Strategy>
 Node* EphemeralRangeTemplate<Strategy>::commonAncestorContainer() const {
   return commonAncestorContainerNode<Strategy>(
       m_startPosition.computeContainerNode(),
       m_endPosition.computeContainerNode());
 }
 
 template <typename Strategy>
 bool EphemeralRangeTemplate<Strategy>::isCollapsed() const {
   DCHECK(isValid());
   return m_startPosition == m_endPosition;
@@ skipping 32 matching lines @@
     return nullptr;
   return Range::create(range.document(), range.startPosition(),
                        range.endPosition());
 }
 
 template class CORE_TEMPLATE_EXPORT EphemeralRangeTemplate<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT
     EphemeralRangeTemplate<EditingInFlatTreeStrategy>;
 
 }  // namespace blink