Introduce use counters for shadow DOM handling in plainText()

Source/core/editing/iterators/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 21 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/Position.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/iterators/WordAwareIterator.h"
 #include "core/frame/FrameView.h"
+#include "core/frame/UseCounter.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutTextControl.h"
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "platform/fonts/Font.h"
@@ skipping 74 matching lines @@
     , m_needsAnotherNewline(false)
     , m_textBox(nullptr)
     , m_remainingTextBox(nullptr)
     , m_firstLetterText(nullptr)
     , m_lastTextNode(nullptr)
     , m_lastTextNodeEndedWithCollapsedSpace(false)
     , m_sortedTextBoxesPosition(0)
     , m_behavior(adjustBehaviorFlags<Strategy>(behavior))
     , m_handledFirstLetter(false)
     , m_shouldStop(false)
+    , m_handleShadowRoot(false)
     // The call to emitsOriginalText() must occur after m_behavior is initialized.
     , m_textState(emitsOriginalText())
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
     if (start.compareTo(end) > 0) {
         initialize(end.containerNode(), end.computeOffsetInContainerNode(), start.containerNode(), start.computeOffsetInContainerNode());
         return;
     }
     initialize(start.containerNode(), start.computeOffsetInContainerNode(), end.containerNode(), end.computeOffsetInContainerNode());
@@ skipping 35 matching lines @@
     // Calculate first out of bounds node.
     m_pastEndNode = endContainer? pastLastNode<Strategy>(*endContainer, endOffset) : nullptr;
 
     // Identify the first run.
     advance();
 }
 
 template<typename Strategy>
 TextIteratorAlgorithm<Strategy>::~TextIteratorAlgorithm()
 {
+    if (!m_handleShadowRoot)
+        return;
+    Document* document = ownerDocument();
+    if (!document)
+        return;
+    if (m_behavior & TextIteratorForInnerText)
+        UseCounter::count(document, UseCounter::InnerTextWithShadowTree);
+    if (m_behavior & TextIteratorForSelectionToString)
+        UseCounter::count(document, UseCounter::SelectionToStringWithShadowTree);
+    if (m_behavior & TextIteratorForWindowFind)
+        UseCounter::count(document, UseCounter::WindowFindWithShadowTree);
 }
 
 template<typename Strategy>
 bool TextIteratorAlgorithm<Strategy>::isInsideReplacedElement() const
 {
     if (atEnd() || length() != 1 || !m_node)
         return false;
 
     LayoutObject* layoutObject = m_node->layoutObject();
     return layoutObject && layoutObject->isReplaced();
@@ skipping 49 matching lines @@
             representNodeOffsetZero();
             m_node = nullptr;
             return;
         }
 
         LayoutObject* layoutObject = m_node->layoutObject();
         if (!layoutObject) {
             if (m_node->isShadowRoot()) {
                 // A shadow root doesn't have a layoutObject, but we want to visit children anyway.
                 m_iterationProgress = m_iterationProgress < HandledNode ? HandledNode : m_iterationProgress;
+                m_handleShadowRoot = true;
             } else {
                 m_iterationProgress = HandledChildren;
             }
         } else {
             // Enter author shadow roots, from youngest, if any and if necessary.
             if (m_iterationProgress < HandledOpenShadowRoots) {
                 if (entersOpenShadowRoots() && m_node->isElementNode() && toElement(m_node)->hasOpenShadowRoot()) {
                     ShadowRoot* youngestShadowRoot = toElement(m_node)->shadowRoot();
                     ASSERT(youngestShadowRoot->type() == ShadowRoot::OpenShadowRoot);
                     m_node = youngestShadowRoot;
@@ skipping 826 matching lines @@
 
 String plainText(const PositionInComposedTree& start, const PositionInComposedTree& end, TextIteratorBehaviorFlags behavior)
 {
     return createPlainText<EditingInComposedTreeStrategy>(start, end, behavior);
 }
 
 template class CORE_TEMPLATE_EXPORT TextIteratorAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT TextIteratorAlgorithm<EditingInComposedTreeStrategy>;
 
 } // namespace blink