Reflow comments in //third_party/WebKit/Source/core/editing/iterators

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 155 matching lines @@
       iterate<FlatTree>(TextIteratorEntersTextControls));
 }
 
 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.
+  // 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<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);
@@ skipping 34 matching lines @@
   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.
+  // TextIterator emits "shadow" since TextIteratorEntersOpenShadowRoots is
+  // specified.
   EXPECT_EQ("[Hello, ][shadow][ iterator.]",
             iterate<DOMTree>(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.
+  // 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<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);
   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<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.
+  // 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<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, StartingAtNodeInShadowRoot) {
@@ skipping 74 matching lines @@
       "<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.
+  // 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<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.
+  // 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<FlatTree>(TextIteratorEntersOpenShadowRoots));
 }
 
 TEST_F(TextIteratorTest, EmitsReplacementCharForInput) {
   static const char* bodyContent =
       "<div contenteditable='true'>"
       "Before"
@@ skipping 222 matching lines @@
   setBodyContent(
       "<div style='width: 2em;'><b><i id='foo'>foo </i></b> bar</div>");
   Element* div = document().querySelector("div");
   Position start(document().getElementById("foo")->firstChild(), 0);
   Position end(div->lastChild(), 4);
   EXPECT_EQ("foo bar", plainText(EphemeralRange(start, end),
                                  TextIteratorEmitsImageAltText));
 }
 
 }  // namespace blink