Rename ComposedTree to FlatTree

third_party/WebKit/Source/core/editing/iterators/TextIteratorTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 #include "core/editing/EditingTestBase.h"
 #include "core/frame/FrameView.h"
 
 namespace blink {
 
 struct DOMTree : NodeTraversal {
     using PositionType = Position;
     using TextIteratorType = TextIterator;
 };
 
-struct ComposedTree : ComposedTreeTraversal {
-    using PositionType = PositionInComposedTree;
-    using TextIteratorType = TextIteratorInComposedTree;
+struct FlatTree : FlatTreeTraversal {
+    using PositionType = PositionInFlatTree;
+    using TextIteratorType = TextIteratorInFlatTree;
 };
 
 class TextIteratorTest : public EditingTestBase {
 protected:
     template <typename Tree>
     std::string iterate(TextIteratorBehavior = TextIteratorDefaultBehavior);
 
     template <typename Tree>
     std::string iteratePartial(const typename Tree::PositionType& start, const typename Tree::PositionType& end, TextIteratorBehavior = TextIteratorDefaultBehavior);
 
@@ skipping 52 matching lines @@
     bs.pop();
 
     EXPECT_TRUE(bs.top());
 }
 
 TEST_F(TextIteratorTest, BasicIteration)
 {
     static const char* input = "<p>Hello, \ntext</p><p>iterator.</p>";
     setBodyContent(input);
     EXPECT_EQ("[Hello, ][text][\n][\n][iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][text][\n][\n][iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][text][\n][\n][iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, IgnoreAltTextInTextControls)
 {
     static const char* input = "<p>Hello <input type='text' value='value'>!</p>";
     setBodyContent(input);
     EXPECT_EQ("[Hello ][][!]", iterate<DOMTree>(TextIteratorEmitsImageAltText));
-    EXPECT_EQ("[Hello ][][\n][value][\n][!]", iterate<ComposedTree>(TextIteratorEmitsImageAltText));
+    EXPECT_EQ("[Hello ][][\n][value][\n][!]", iterate<FlatTree>(TextIteratorEmitsImageAltText));
 }
 
 TEST_F(TextIteratorTest, DisplayAltTextInImageControls)
 {
     static const char* input = "<p>Hello <input type='image' alt='alt'>!</p>";
     setBodyContent(input);
     EXPECT_EQ("[Hello ][alt][!]", iterate<DOMTree>(TextIteratorEmitsImageAltText));
-    EXPECT_EQ("[Hello ][alt][!]", iterate<ComposedTree>(TextIteratorEmitsImageAltText));
+    EXPECT_EQ("[Hello ][alt][!]", iterate<FlatTree>(TextIteratorEmitsImageAltText));
 }
 
 TEST_F(TextIteratorTest, NotEnteringTextControls)
 {
     static const char* input = "<p>Hello <input type='text' value='input'>!</p>";
     setBodyContent(input);
     EXPECT_EQ("[Hello ][][!]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello ][][\n][input][\n][!]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello ][][\n][input][\n][!]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, EnteringTextControlsWithOption)
 {
     static const char* input = "<p>Hello <input type='text' value='input'>!</p>";
     setBodyContent(input);
     EXPECT_EQ("[Hello ][\n][input][!]", iterate<DOMTree>(TextIteratorEntersTextControls));
-    EXPECT_EQ("[Hello ][][\n][input][\n][!]", iterate<ComposedTree>(TextIteratorEntersTextControls));
+    EXPECT_EQ("[Hello ][][\n][input][\n][!]", iterate<FlatTree>(TextIteratorEntersTextControls));
 }
 
 TEST_F(TextIteratorTest, EnteringTextControlsWithOptionComplex)
 {
     static const char* input = "<input type='text' value='Beginning of range'><div><div><input type='text' value='Under DOM nodes'></div></div><input type='text' value='End of range'>";
     setBodyContent(input);
     EXPECT_EQ("[\n][Beginning of range][\n][Under DOM nodes][\n][End of range]", iterate<DOMTree>(TextIteratorEntersTextControls));
-    EXPECT_EQ("[][\n][Beginning of range][\n][][\n][Under DOM nodes][\n][][\n][End of range]", iterate<ComposedTree>(TextIteratorEntersTextControls));
+    EXPECT_EQ("[][\n][Beginning of range][\n][][\n][Under DOM nodes][\n][][\n][End of range]", iterate<FlatTree>(TextIteratorEntersTextControls));
 }
 
 TEST_F(TextIteratorTest, NotEnteringTextControlHostingShadowTreeEvenWithOption)
 {
     static const char* bodyContent = "<div>Hello, <input type='text' value='input' id='input'> iterator.</div>";
     static const char* shadowContent = "<span>shadow</span>";
     // TextIterator doesn't emit "input" nor "shadow" since (1) the layoutObject for <input> is not created; and
     // (2) we don't (yet) recurse into shadow trees.
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "input", shadowContent);
     // FIXME: Why is an empty string emitted here?
     EXPECT_EQ("[Hello, ][][ iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][][shadow][ iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][][shadow][ iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, NotEnteringShadowTree)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span>shadow</span>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     // TextIterator doesn't emit "text" since its layoutObject is not created. The shadow tree is ignored.
     EXPECT_EQ("[Hello, ][ iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][shadow][ iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][shadow][ iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, NotEnteringShadowTreeWithMultipleShadowTrees)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent1 = "<span>first shadow</span>";
     static const char* shadowContent2 = "<span>second shadow</span>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent1);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent2);
     EXPECT_EQ("[Hello, ][ iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][second shadow][ iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][second shadow][ iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, NotEnteringShadowTreeWithNestedShadowTrees)
 {
     static const char* bodyContent = "<div>Hello, <span id='host-in-document'>text</span> iterator.</div>";
     static const char* shadowContent1 = "<span>first <span id='host-in-shadow'>shadow</span></span>";
     static const char* shadowContent2 = "<span>second shadow</span>";
     setBodyContent(bodyContent);
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot1 = createShadowRootForElementWithIDAndSetInnerHTML(document(), "host-in-document", shadowContent1);
     createShadowRootForElementWithIDAndSetInnerHTML(*shadowRoot1, "host-in-shadow", shadowContent2);
     EXPECT_EQ("[Hello, ][ iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][first ][second shadow][ iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][first ][second shadow][ iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, NotEnteringShadowTreeWithContentInsertionPoint)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span>shadow <content>content</content></span>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     // In this case a layoutObject for "text" is created, so it shows up here.
     EXPECT_EQ("[Hello, ][text][ iterator.]", iterate<DOMTree>());
-    EXPECT_EQ("[Hello, ][shadow ][text][ iterator.]", iterate<ComposedTree>());
+    EXPECT_EQ("[Hello, ][shadow ][text][ iterator.]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, EnteringShadowTreeWithOption)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span>shadow</span>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     // TextIterator emits "shadow" since TextIteratorEntersOpenShadowRoots is specified.
     EXPECT_EQ("[Hello, ][shadow][ iterator.]", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("[Hello, ][shadow][ iterator.]", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("[Hello, ][shadow][ iterator.]", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, EnteringShadowTreeWithMultipleShadowTreesWithOption)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent1 = "<span>first shadow</span>";
     static const char* shadowContent2 = "<span>second shadow</span>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent1);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent2);
     // The first isn't emitted because a layoutObject for the first is not created.
     EXPECT_EQ("[Hello, ][second shadow][ iterator.]", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("[Hello, ][second shadow][ iterator.]", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("[Hello, ][second shadow][ iterator.]", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, EnteringShadowTreeWithNestedShadowTreesWithOption)
 {
     static const char* bodyContent = "<div>Hello, <span id='host-in-document'>text</span> iterator.</div>";
     static const char* shadowContent1 = "<span>first <span id='host-in-shadow'>shadow</span></span>";
     static const char* shadowContent2 = "<span>second shadow</span>";
     setBodyContent(bodyContent);
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot1 = createShadowRootForElementWithIDAndSetInnerHTML(document(), "host-in-document", shadowContent1);
     createShadowRootForElementWithIDAndSetInnerHTML(*shadowRoot1, "host-in-shadow", shadowContent2);
     EXPECT_EQ("[Hello, ][first ][second shadow][ iterator.]", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("[Hello, ][first ][second shadow][ iterator.]", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("[Hello, ][first ][second shadow][ iterator.]", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, EnteringShadowTreeWithContentInsertionPointWithOption)
 {
     static const char* bodyContent = "<div>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span><content>content</content> shadow</span>";
     // In this case a layoutObject for "text" is created, and emitted AFTER any nodes in the shadow tree.
     // This order does not match the order of the rendered texts, but at this moment it's the expected behavior.
     // FIXME: Fix this. We probably need pure-renderer-based implementation of TextIterator to achieve this.
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     EXPECT_EQ("[Hello, ][ shadow][text][ iterator.]", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("[Hello, ][text][ shadow][ iterator.]", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("[Hello, ][text][ shadow][ iterator.]", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, StartingAtNodeInShadowRoot)
 {
     static const char* bodyContent = "<div id='outer'>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span><content>content</content> shadow</span>";
     setBodyContent(bodyContent);
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot = createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     Node* outerDiv = document().getElementById("outer");
     Node* spanInShadow = shadowRoot->firstChild();
     Position start(spanInShadow, PositionAnchorType::BeforeChildren);
     Position end(outerDiv, PositionAnchorType::AfterChildren);
     EXPECT_EQ("[ shadow][text][ iterator.]", iteratePartial<DOMTree>(start, end, TextIteratorEntersOpenShadowRoots));
 
-    PositionInComposedTree startInComposedTree(spanInShadow, PositionAnchorType::BeforeChildren);
-    PositionInComposedTree endInComposedTree(outerDiv, PositionAnchorType::AfterChildren);
-    EXPECT_EQ("[text][ shadow][ iterator.]", iteratePartial<ComposedTree>(startInComposedTree, endInComposedTree, TextIteratorEntersOpenShadowRoots));
+    PositionInFlatTree startInFlatTree(spanInShadow, PositionAnchorType::BeforeChildren);
+    PositionInFlatTree endInFlatTree(outerDiv, PositionAnchorType::AfterChildren);
+    EXPECT_EQ("[text][ shadow][ iterator.]", iteratePartial<FlatTree>(startInFlatTree, endInFlatTree, TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, FinishingAtNodeInShadowRoot)
 {
     static const char* bodyContent = "<div id='outer'>Hello, <span id='host'>text</span> iterator.</div>";
     static const char* shadowContent = "<span><content>content</content> shadow</span>";
     setBodyContent(bodyContent);
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot = createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     Node* outerDiv = document().getElementById("outer");
     Node* spanInShadow = shadowRoot->firstChild();
     Position start(outerDiv, PositionAnchorType::BeforeChildren);
     Position end(spanInShadow, PositionAnchorType::AfterChildren);
     EXPECT_EQ("[Hello, ][ shadow]", iteratePartial<DOMTree>(start, end, TextIteratorEntersOpenShadowRoots));
 
-    PositionInComposedTree startInComposedTree(outerDiv, PositionAnchorType::BeforeChildren);
-    PositionInComposedTree endInComposedTree(spanInShadow, PositionAnchorType::AfterChildren);
-    EXPECT_EQ("[Hello, ][text][ shadow]", iteratePartial<ComposedTree>(startInComposedTree, endInComposedTree, TextIteratorEntersOpenShadowRoots));
+    PositionInFlatTree startInFlatTree(outerDiv, PositionAnchorType::BeforeChildren);
+    PositionInFlatTree endInFlatTree(spanInShadow, PositionAnchorType::AfterChildren);
+    EXPECT_EQ("[Hello, ][text][ shadow]", iteratePartial<FlatTree>(startInFlatTree, endInFlatTree, TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, FullyClipsContents)
 {
     static const char* bodyContent =
         "<div style='overflow: hidden; width: 200px; height: 0;'>"
         "I'm invisible"
         "</div>";
     setBodyContent(bodyContent);
     EXPECT_EQ("", iterate<DOMTree>());
-    EXPECT_EQ("", iterate<ComposedTree>());
+    EXPECT_EQ("", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, IgnoresContainerClip)
 {
     static const char* bodyContent =
         "<div style='overflow: hidden; width: 200px; height: 0;'>"
         "<div>I'm not visible</div>"
         "<div style='position: absolute; width: 200px; height: 200px; top: 0; right: 0;'>"
         "but I am!"
         "</div>"
         "</div>";
     setBodyContent(bodyContent);
     EXPECT_EQ("[but I am!]", iterate<DOMTree>());
-    EXPECT_EQ("[but I am!]", iterate<ComposedTree>());
+    EXPECT_EQ("[but I am!]", iterate<FlatTree>());
 }
 
 TEST_F(TextIteratorTest, FullyClippedContentsDistributed)
 {
     static const char* bodyContent =
         "<div id='host'>"
         "<div>Am I visible?</div>"
         "</div>";
     static const char* shadowContent =
         "<div style='overflow: hidden; width: 200px; height: 0;'>"
         "<content></content>"
         "</div>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     // FIXME: The text below is actually invisible but TextIterator currently thinks it's visible.
     EXPECT_EQ("[\n][Am I visible?]", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, IgnoresContainersClipDistributed)
 {
     static const char* bodyContent =
         "<div id='host' style='overflow: hidden; width: 200px; height: 0;'>"
         "<div>Nobody can find me!</div>"
         "</div>";
     static const char* shadowContent =
         "<div style='position: absolute; width: 200px; height: 200px; top: 0; right: 0;'>"
         "<content></content>"
         "</div>";
     setBodyContent(bodyContent);
     createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
     // FIXME: The text below is actually visible but TextIterator currently thinks it's invisible.
     // [\n][Nobody can find me!]
     EXPECT_EQ("", iterate<DOMTree>(TextIteratorEntersOpenShadowRoots));
-    EXPECT_EQ("[Nobody can find me!]", iterate<ComposedTree>(TextIteratorEntersOpenShadowRoots));
+    EXPECT_EQ("[Nobody can find me!]", iterate<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, EmitsReplacementCharForInput)
 {
     static const char* bodyContent =
         "<div contenteditable='true'>"
         "Before"
         "<img src='foo.png'>"
         "After"
         "</div>";
     setBodyContent(bodyContent);
     EXPECT_EQ("[Before][\xEF\xBF\xBC][After]", iterate<DOMTree>(TextIteratorEmitsObjectReplacementCharacter));
-    EXPECT_EQ("[Before][\xEF\xBF\xBC][After]", iterate<ComposedTree>(TextIteratorEmitsObjectReplacementCharacter));
+    EXPECT_EQ("[Before][\xEF\xBF\xBC][After]", iterate<FlatTree>(TextIteratorEmitsObjectReplacementCharacter));
 }
 
 TEST_F(TextIteratorTest, RangeLengthWithReplacedElements)
 {
     static const char* bodyContent =
         "<div id='div' contenteditable='true'>1<img src='foo.png'>3</div>";
     setBodyContent(bodyContent);
     document().view()->updateAllLifecyclePhases();
 
     Node* divNode = document().getElementById("div");
     RefPtrWillBeRawPtr<Range> range = Range::create(document(), divNode, 0, divNode, 3);
 
     EXPECT_EQ(3, TextIterator::rangeLength(range->startPosition(), range->endPosition()));
 }
 
 TEST_F(TextIteratorTest, WhitespaceCollapseForReplacedElements)
 {
     static const char* bodyContent = "<span>Some text </span> <input type='button' value='Button text'/><span>Some more text</span>";
     setBodyContent(bodyContent);
     EXPECT_EQ("[Some text ][][Some more text]", iterate<DOMTree>(TextIteratorCollapseTrailingSpace));
-    EXPECT_EQ("[Some text ][][Button text][Some more text]", iterate<ComposedTree>(TextIteratorCollapseTrailingSpace));
+    EXPECT_EQ("[Some text ][][Button text][Some more text]", iterate<FlatTree>(TextIteratorCollapseTrailingSpace));
 }
 
 TEST_F(TextIteratorTest, copyTextTo)
 {
     const char* bodyContent = "<a id=host><b id=one>one</b> not appeared <b id=two>two</b></a>";
     const char* shadowContent = "three <content select=#two></content> <content select=#one></content> zero";
     setBodyContent(bodyContent);
     setShadowContent(shadowContent, "host");
     updateLayoutAndStyleForPainting();
 
     Element* host = document().getElementById("host");
     const char* message = "|iter%d| should have emitted '%s'.";
 
     EphemeralRangeTemplate<EditingStrategy> range1(EphemeralRangeTemplate<EditingStrategy>::rangeOfContents(*host));
     TextIteratorAlgorithm<EditingStrategy> iter1(range1.startPosition(), range1.endPosition());
     ForwardsTextBuffer output1;
     iter1.copyTextTo(&output1, 0, 2);
     EXPECT_EQ("on", String(output1.data(), output1.size())) << String::format(message, 1, "on").utf8().data();
     iter1.copyTextTo(&output1, 2, 1);
     EXPECT_EQ("one", String(output1.data(), output1.size())) << String::format(message, 1, "one").utf8().data();
     iter1.advance();
     iter1.copyTextTo(&output1, 0, 1);
     EXPECT_EQ("onet", String(output1.data(), output1.size())) << String::format(message, 1, "onet").utf8().data();
     iter1.copyTextTo(&output1, 1, 2);
     EXPECT_EQ("onetwo", String(output1.data(), output1.size())) << String::format(message, 1, "onetwo").utf8().data();
 
-    EphemeralRangeTemplate<EditingInComposedTreeStrategy> range2(EphemeralRangeTemplate<EditingInComposedTreeStrategy>::rangeOfContents(*host));
-    TextIteratorAlgorithm<EditingInComposedTreeStrategy> iter2(range2.startPosition(), range2.endPosition());
+    EphemeralRangeTemplate<EditingInFlatTreeStrategy> range2(EphemeralRangeTemplate<EditingInFlatTreeStrategy>::rangeOfContents(*host));
+    TextIteratorAlgorithm<EditingInFlatTreeStrategy> iter2(range2.startPosition(), range2.endPosition());
     ForwardsTextBuffer output2;
     iter2.copyTextTo(&output2, 0, 3);
     EXPECT_EQ("thr", String(output2.data(), output2.size())) << String::format(message, 2, "thr").utf8().data();
     iter2.copyTextTo(&output2, 3, 3);
     EXPECT_EQ("three ", String(output2.data(), output2.size())) << String::format(message, 2, "three ").utf8().data();
     iter2.advance();
     iter2.copyTextTo(&output2, 0, 2);
     EXPECT_EQ("three tw", String(output2.data(), output2.size())) << String::format(message, 2, "three tw").utf8().data();
     iter2.copyTextTo(&output2, 2, 1);
     EXPECT_EQ("three two", String(output2.data(), output2.size())) << String::format(message, 2, "three two").utf8().data();
@@ skipping 26 matching lines @@
     TextIteratorAlgorithm<EditingStrategy> iter1(range1.startPosition(), range1.endPosition());
     const char* message1 = "|iter1| should emit 'one' and 'two'.";
     EXPECT_EQ('o', iter1.characterAt(0)) << message1;
     EXPECT_EQ('n', iter1.characterAt(1)) << message1;
     EXPECT_EQ('e', iter1.characterAt(2)) << message1;
     iter1.advance();
     EXPECT_EQ('t', iter1.characterAt(0)) << message1;
     EXPECT_EQ('w', iter1.characterAt(1)) << message1;
     EXPECT_EQ('o', iter1.characterAt(2)) << message1;
 
-    EphemeralRangeTemplate<EditingInComposedTreeStrategy> range2(EphemeralRangeTemplate<EditingInComposedTreeStrategy>::rangeOfContents(*host));
-    TextIteratorAlgorithm<EditingInComposedTreeStrategy> iter2(range2.startPosition(), range2.endPosition());
+    EphemeralRangeTemplate<EditingInFlatTreeStrategy> range2(EphemeralRangeTemplate<EditingInFlatTreeStrategy>::rangeOfContents(*host));
+    TextIteratorAlgorithm<EditingInFlatTreeStrategy> iter2(range2.startPosition(), range2.endPosition());
     const char* message2 = "|iter2| should emit 'three ', 'two', ' ', 'one' and ' zero'.";
     EXPECT_EQ('t', iter2.characterAt(0)) << message2;
     EXPECT_EQ('h', iter2.characterAt(1)) << message2;
     EXPECT_EQ('r', iter2.characterAt(2)) << message2;
     EXPECT_EQ('e', iter2.characterAt(3)) << message2;
     EXPECT_EQ('e', iter2.characterAt(4)) << message2;
     EXPECT_EQ(' ', iter2.characterAt(5)) << message2;
     iter2.advance();
     EXPECT_EQ('t', iter2.characterAt(0)) << message2;
     EXPECT_EQ('w', iter2.characterAt(1)) << message2;
@@ skipping 26 matching lines @@
     EXPECT_EQ(2, iter.copyTextTo(&buffer, 0, 1)) << "Should emit 2 UChars for 'U+13000'.";
     EXPECT_EQ(4, iter.copyTextTo(&buffer, 2, 3)) << "Should emit 4 UChars for 'U+13001U+13002'.";
     EXPECT_EQ(3, iter.copyTextTo(&buffer, 6, 2)) << "Should emit 3 UChars for ' U+13140'.";
     EXPECT_EQ(2, iter.copyTextTo(&buffer, 9, 2)) << "Should emit 2 UChars for 'U+13141'.";
     EXPECT_EQ(1, iter.copyTextTo(&buffer, 11, 1)) << "Should emit 1 UChar for '.'.";
     for (int i = 0; i < 12; i++)
         EXPECT_EQ(expected[i], buffer[i]);
 }
 
 } // namespace blink