Rename {Author,UserAgent}ShadowRoot to {Open,Closed}ShadowRoot.

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 83 matching lines @@
     , m_sortedTextBoxesPosition(0)
     , m_hasEmitted(false)
     , m_emitsCharactersBetweenAllVisiblePositions(behavior & TextIteratorEmitsCharactersBetweenAllVisiblePositions)
     , m_entersTextControls(behavior & TextIteratorEntersTextControls)
     , m_emitsOriginalText(behavior & TextIteratorEmitsOriginalText)
     , m_handledFirstLetter(false)
     , m_ignoresStyleVisibility(behavior & TextIteratorIgnoresStyleVisibility)
     , m_stopsOnFormControls(behavior & TextIteratorStopsOnFormControls)
     , m_shouldStop(false)
     , m_emitsImageAltText(behavior & TextIteratorEmitsImageAltText)
-    , m_entersAuthorShadowRoots(behavior & TextIteratorEntersAuthorShadowRoots)
+    , m_entersOpenShadowRoots(behavior & TextIteratorEntersOpenShadowRoots)
     , m_emitsObjectReplacementCharacter(behavior & TextIteratorEmitsObjectReplacementCharacter)
     , m_breaksAtReplacedElement(!(behavior & TextIteratorDoesNotBreakAtReplacedElement))
 {
     if (range)
         initialize(range->startPosition(), range->endPosition());
 }
 
 TextIterator::TextIterator(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
     : m_startContainer(nullptr)
     , m_startOffset(0)
@@ skipping 11 matching lines @@
     , m_sortedTextBoxesPosition(0)
     , m_hasEmitted(false)
     , m_emitsCharactersBetweenAllVisiblePositions(behavior & TextIteratorEmitsCharactersBetweenAllVisiblePositions)
     , m_entersTextControls(behavior & TextIteratorEntersTextControls)
     , m_emitsOriginalText(behavior & TextIteratorEmitsOriginalText)
     , m_handledFirstLetter(false)
     , m_ignoresStyleVisibility(behavior & TextIteratorIgnoresStyleVisibility)
     , m_stopsOnFormControls(behavior & TextIteratorStopsOnFormControls)
     , m_shouldStop(false)
     , m_emitsImageAltText(behavior & TextIteratorEmitsImageAltText)
-    , m_entersAuthorShadowRoots(behavior & TextIteratorEntersAuthorShadowRoots)
+    , m_entersOpenShadowRoots(behavior & TextIteratorEntersOpenShadowRoots)
     , m_emitsObjectReplacementCharacter(behavior & TextIteratorEmitsObjectReplacementCharacter)
     , m_breaksAtReplacedElement(!(behavior & TextIteratorDoesNotBreakAtReplacedElement))
 {
     initialize(start, end);
 }
 
 void TextIterator::initialize(const Position& start, const Position& end)
 {
     ASSERT(comparePositions(start, end) <= 0);
 
@@ skipping 115 matching lines @@
         LayoutObject* renderer = m_node->renderer();
         if (!renderer) {
             if (m_node->isShadowRoot()) {
                 // A shadow root doesn't have a renderer, but we want to visit children anyway.
                 m_iterationProgress = m_iterationProgress < HandledNode ? HandledNode : m_iterationProgress;
             } else {
                 m_iterationProgress = HandledChildren;
             }
         } else {
             // Enter author shadow roots, from youngest, if any and if necessary.
-            if (m_iterationProgress < HandledAuthorShadowRoots) {
-                if (m_entersAuthorShadowRoots && m_node->isElementNode() && toElement(m_node)->hasAuthorShadowRoot()) {
+            if (m_iterationProgress < HandledOpenShadowRoots) {
+                if (m_entersOpenShadowRoots && m_node->isElementNode() && toElement(m_node)->hasOpenShadowRoot()) {
                     ShadowRoot* youngestShadowRoot = toElement(m_node)->shadowRoot();
-                    ASSERT(youngestShadowRoot->type() == ShadowRoot::AuthorShadowRoot);
+                    ASSERT(youngestShadowRoot->type() == ShadowRoot::OpenShadowRoot);
                     m_node = youngestShadowRoot;
                     m_iterationProgress = HandledNone;
                     ++m_shadowDepth;
                     m_fullyClippedStack.pushFullyClippedState(m_node);
                     continue;
                 }
 
-                m_iterationProgress = HandledAuthorShadowRoots;
+                m_iterationProgress = HandledOpenShadowRoots;
             }
 
             // Enter user-agent shadow root, if necessary.
-            if (m_iterationProgress < HandledUserAgentShadowRoot) {
+            if (m_iterationProgress < HandledClosedShadowRoot) {
                 if (m_entersTextControls && renderer->isTextControl()) {
-                    ShadowRoot* userAgentShadowRoot = toElement(m_node)->userAgentShadowRoot();
-                    ASSERT(userAgentShadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
-                    m_node = userAgentShadowRoot;
+                    ShadowRoot* closedShadowRoot = toElement(m_node)->closedShadowRoot();
+                    ASSERT(closedShadowRoot->type() == ShadowRoot::ClosedShadowRoot);
+                    m_node = closedShadowRoot;
                     m_iterationProgress = HandledNone;
                     ++m_shadowDepth;
                     m_fullyClippedStack.pushFullyClippedState(m_node);
                     continue;
                 }
-                m_iterationProgress = HandledUserAgentShadowRoot;
+                m_iterationProgress = HandledClosedShadowRoot;
             }
 
             // Handle the current node according to its type.
             if (m_iterationProgress < HandledNode) {
                 bool handledNode = false;
                 if (renderer->isText() && m_node->nodeType() == Node::TEXT_NODE) { // FIXME: What about CDATA_SECTION_NODE?
                     handledNode = handleTextNode();
                 } else if (renderer && (renderer->isImage() || renderer->isLayoutPart()
                     || (m_node && m_node->isHTMLElement()
                     && (isHTMLFormControlElement(toHTMLElement(*m_node))
@@ skipping 38 matching lines @@
                         m_iterationProgress = HandledChildren;
                         return;
                     }
                     next = m_node->nextSibling();
                 }
 
                 if (!next && !parentNode && m_shadowDepth > 0) {
                     // 4. Reached the top of a shadow root. If it's created by author, then try to visit the next
                     // sibling shadow root, if any.
                     ShadowRoot* shadowRoot = toShadowRoot(m_node);
-                    if (shadowRoot->type() == ShadowRoot::AuthorShadowRoot) {
+                    if (shadowRoot->type() == ShadowRoot::OpenShadowRoot) {
                         ShadowRoot* nextShadowRoot = shadowRoot->olderShadowRoot();
-                        if (nextShadowRoot && nextShadowRoot->type() == ShadowRoot::AuthorShadowRoot) {
+                        if (nextShadowRoot && nextShadowRoot->type() == ShadowRoot::OpenShadowRoot) {
                             m_fullyClippedStack.pop();
                             m_node = nextShadowRoot;
                             m_iterationProgress = HandledNone;
                             // m_shadowDepth is unchanged since we exit from a shadow root and enter another.
                             m_fullyClippedStack.pushFullyClippedState(m_node);
                         } else {
                             // We are the last shadow root; exit from here and go back to where we were.
                             m_node = shadowRoot->host();
-                            m_iterationProgress = HandledAuthorShadowRoots;
+                            m_iterationProgress = HandledOpenShadowRoots;
                             --m_shadowDepth;
                             m_fullyClippedStack.pop();
                         }
                     } else {
                         // If we are in a user-agent shadow root, then go back to the host.
-                        ASSERT(shadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
+                        ASSERT(shadowRoot->type() == ShadowRoot::ClosedShadowRoot);
                         m_node = shadowRoot->host();
-                        m_iterationProgress = HandledUserAgentShadowRoot;
+                        m_iterationProgress = HandledClosedShadowRoot;
                         --m_shadowDepth;
                         m_fullyClippedStack.pop();
                     }
                     m_handledFirstLetter = false;
                     m_firstLetterText = nullptr;
                     continue;
                 }
             }
             m_fullyClippedStack.pop();
         }
@@ skipping 791 matching lines @@
     return createPlainText(it);
 }
 
 String plainText(const Position& start, const Position& end, TextIteratorBehaviorFlags behavior)
 {
     TextIterator it(start, end, behavior);
     return createPlainText(it);
 }
 
 }