Reformat comments in core/layout up until LayoutMultiColumnFlowThread

third_party/WebKit/Source/core/layout/LayoutMultiColumnFlowThreadTest.cpp

 // Copyright 2014 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/layout/LayoutMultiColumnFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
 #include "core/layout/LayoutTestHelper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 namespace {
 
 class MultiColumnRenderingTest : public RenderingTest {
  public:
   LayoutMultiColumnFlowThread* findFlowThread(const char* id) const;
 
-  // Generate a signature string based on what kind of column boxes the flow thread has
-  // established. 'c' is used for regular column content sets, while 's' is used for spanners.
-  // '?' is used when there's an unknown box type (which should be considered a failure).
+  // Generate a signature string based on what kind of column boxes the flow
+  // thread has established. 'c' is used for regular column content sets, while
+  // 's' is used for spanners. '?' is used when there's an unknown box type
+  // (which should be considered a failure).
   String columnSetSignature(LayoutMultiColumnFlowThread*);
   String columnSetSignature(const char* multicolId);
 
   void setMulticolHTML(const String&);
 };
 
 LayoutMultiColumnFlowThread* MultiColumnRenderingTest::findFlowThread(
     const char* id) const {
   if (LayoutBlockFlow* multicolContainer =
           toLayoutBlockFlow(getLayoutObjectByElementId(id)))
@@ skipping 23 matching lines @@
 void MultiColumnRenderingTest::setMulticolHTML(const String& html) {
   const char* style =
       "<style>"
       "  #mc { columns:2; }"
       "  .s, #spanner, #spanner1, #spanner2 { column-span:all; }"
       "</style>";
   setBodyInnerHTML(style + html);
 }
 
 TEST_F(MultiColumnRenderingTest, OneBlockWithInDepthTreeStructureCheck) {
-  // Examine the layout tree established by a simple multicol container with a block with some text inside.
+  // Examine the layout tree established by a simple multicol container with a
+  // block with some text inside.
   setMulticolHTML("<div id='mc'><div>xxx</div></div>");
   LayoutBlockFlow* multicolContainer =
       toLayoutBlockFlow(getLayoutObjectByElementId("mc"));
   ASSERT_TRUE(multicolContainer);
   LayoutMultiColumnFlowThread* flowThread =
       multicolContainer->multiColumnFlowThread();
   ASSERT_TRUE(flowThread);
   EXPECT_EQ(columnSetSignature(flowThread), "c");
   EXPECT_EQ(flowThread->parent(), multicolContainer);
   EXPECT_FALSE(flowThread->previousSibling());
@@ skipping 20 matching lines @@
   setMulticolHTML("<div id='mc'><div id='block'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "c");
   LayoutMultiColumnSet* columnSet = flowThread->firstMultiColumnSet();
   EXPECT_EQ(
       flowThread->mapDescendantToColumnSet(getLayoutObjectByElementId("block")),
       columnSet);
 }
 
 TEST_F(MultiColumnRenderingTest, TwoBlocks) {
-  // No matter how much content, we should only create one column set (unless there are spanners).
+  // No matter how much content, we should only create one column set (unless
+  // there are spanners).
   setMulticolHTML(
       "<div id='mc'><div id='block1'></div><div id='block2'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "c");
   LayoutMultiColumnSet* columnSet = flowThread->firstMultiColumnSet();
   EXPECT_EQ(flowThread->mapDescendantToColumnSet(
                 getLayoutObjectByElementId("block1")),
             columnSet);
   EXPECT_EQ(flowThread->mapDescendantToColumnSet(
                 getLayoutObjectByElementId("block2")),
             columnSet);
 }
 
 TEST_F(MultiColumnRenderingTest, Spanner) {
   // With one spanner and no column content, we should create a spanner set.
   setMulticolHTML("<div id='mc'><div id='spanner'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "s");
   LayoutBox* columnBox = flowThread->firstMultiColumnBox();
   EXPECT_EQ(flowThread->firstMultiColumnSet(), nullptr);
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("spanner")),
             columnBox);
   EXPECT_EQ(getLayoutObjectByElementId("spanner")->spannerPlaceholder(),
             columnBox);
 }
 
 TEST_F(MultiColumnRenderingTest, ContentThenSpanner) {
-  // With some column content followed by a spanner, we need a column set followed by a spanner set.
+  // With some column content followed by a spanner, we need a column set
+  // followed by a spanner set.
   setMulticolHTML(
       "<div id='mc'><div id='columnContent'></div><div "
       "id='spanner'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "cs");
   LayoutBox* columnBox = flowThread->firstMultiColumnBox();
   EXPECT_EQ(flowThread->mapDescendantToColumnSet(
                 getLayoutObjectByElementId("columnContent")),
             columnBox);
   columnBox = columnBox->nextSiblingMultiColumnBox();
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("spanner")),
             columnBox);
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("columnContent")),
             nullptr);
 }
 
 TEST_F(MultiColumnRenderingTest, SpannerThenContent) {
-  // With a spanner followed by some column content, we need a spanner set followed by a column set.
+  // With a spanner followed by some column content, we need a spanner set
+  // followed by a column set.
   setMulticolHTML(
       "<div id='mc'><div id='spanner'></div><div "
       "id='columnContent'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "sc");
   LayoutBox* columnBox = flowThread->firstMultiColumnBox();
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("spanner")),
             columnBox);
   columnBox = columnBox->nextSiblingMultiColumnBox();
   EXPECT_EQ(flowThread->mapDescendantToColumnSet(
                 getLayoutObjectByElementId("columnContent")),
             columnBox);
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("columnContent")),
             nullptr);
 }
 
 TEST_F(MultiColumnRenderingTest, ContentThenSpannerThenContent) {
-  // With column content followed by a spanner followed by some column content, we need a column
+  // With column content followed by a spanner followed by some column content,
+  // we need a column
   // set followed by a spanner set followed by a column set.
   setMulticolHTML(
       "<div id='mc'><div id='columnContentBefore'></div><div "
       "id='spanner'></div><div id='columnContentAfter'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "csc");
   LayoutBox* columnBox = flowThread->firstMultiColumnSet();
   EXPECT_EQ(flowThread->mapDescendantToColumnSet(
                 getLayoutObjectByElementId("columnContentBefore")),
             columnBox);
@@ skipping 28 matching lines @@
             columnBox);
   columnBox = columnBox->nextSiblingMultiColumnBox();
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("spanner2")),
             columnBox);
   EXPECT_EQ(getLayoutObjectByElementId("spanner2")->spannerPlaceholder(),
             columnBox);
 }
 
 TEST_F(MultiColumnRenderingTest, SpannerThenContentThenSpanner) {
-  // With two spanners and some column content in-between, we need a spanner set, a column set and another spanner set.
+  // With two spanners and some column content in-between, we need a spanner
+  // set, a column set and another spanner set.
   setMulticolHTML(
       "<div id='mc'><div id='spanner1'></div><div "
       "id='columnContent'></div><div id='spanner2'></div></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   ASSERT_EQ(columnSetSignature(flowThread), "scs");
   LayoutMultiColumnSet* columnSet = flowThread->firstMultiColumnSet();
   EXPECT_EQ(columnSet->nextSiblingMultiColumnSet(), nullptr);
   LayoutBox* columnBox = flowThread->firstMultiColumnBox();
   EXPECT_EQ(flowThread->containingColumnSpannerPlaceholder(
                 getLayoutObjectByElementId("spanner1")),
@@ skipping 325 matching lines @@
   void setMulticolHTML(const char*);
   void reparentLayoutObject(const char* newParentId,
                             const char* childId,
                             const char* insertBeforeId = nullptr);
   void destroyLayoutObject(LayoutObject* child);
   void destroyLayoutObject(const char* childId);
 };
 
 void MultiColumnTreeModifyingTest::setMulticolHTML(const char* html) {
   MultiColumnRenderingTest::setMulticolHTML(html);
-  // Allow modifications to the layout tree structure, because that's what we want to test.
+  // Allow modifications to the layout tree structure, because that's what we
+  // want to test.
   document().lifecycle().advanceTo(DocumentLifecycle::InStyleRecalc);
 }
 
 void MultiColumnTreeModifyingTest::reparentLayoutObject(
     const char* newParentId,
     const char* childId,
     const char* insertBeforeId) {
   LayoutObject* newParent = getLayoutObjectByElementId(newParentId);
   LayoutObject* child = getLayoutObjectByElementId(childId);
   LayoutObject* insertBefore =
       insertBeforeId ? getLayoutObjectByElementId(insertBeforeId) : nullptr;
   child->remove();
   newParent->addChild(child, insertBefore);
 }
 
 void MultiColumnTreeModifyingTest::destroyLayoutObject(LayoutObject* child) {
-  // Remove and destroy in separate steps, so that we get to test removal of subtrees.
+  // Remove and destroy in separate steps, so that we get to test removal of
+  // subtrees.
   child->remove();
   child->node()->detachLayoutTree();
 }
 
 void MultiColumnTreeModifyingTest::destroyLayoutObject(const char* childId) {
   destroyLayoutObject(getLayoutObjectByElementId(childId));
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertFirstContentAndRemove) {
   setMulticolHTML("<div id='block'></div><div id='mc'></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   LayoutBlockFlow* block =
       toLayoutBlockFlow(getLayoutObjectByElementId("block"));
   LayoutBlockFlow* multicolContainer =
       toLayoutBlockFlow(getLayoutObjectByElementId("mc"));
   block->remove();
   multicolContainer->addChild(block);
   EXPECT_EQ(block->parent(), flowThread);
   // A set should have appeared, now that the multicol container has content.
   EXPECT_EQ(columnSetSignature(flowThread), "c");
 
   destroyLayoutObject(block);
-  // The set should be gone again now, since there's nothing inside the multicol container anymore.
+  // The set should be gone again now, since there's nothing inside the multicol
+  // container anymore.
   EXPECT_EQ(columnSetSignature("mc"), "");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertContentBeforeContentAndRemove) {
   setMulticolHTML(
       "<div id='block'></div><div id='mc'><div id='insertBefore'></div></div>");
   EXPECT_EQ(columnSetSignature("mc"), "c");
   reparentLayoutObject("mc", "block", "insertBefore");
-  // There was already some content prior to our insertion, so no new set should be inserted.
+  // There was already some content prior to our insertion, so no new set should
+  // be inserted.
   EXPECT_EQ(columnSetSignature("mc"), "c");
   destroyLayoutObject("block");
   // There's still some content after the removal, so the set should remain.
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertContentAfterContentAndRemove) {
   setMulticolHTML("<div id='block'></div><div id='mc'><div></div></div>");
   EXPECT_EQ(columnSetSignature("mc"), "c");
   reparentLayoutObject("mc", "block");
-  // There was already some content prior to our insertion, so no new set should be inserted.
+  // There was already some content prior to our insertion, so no new set should
+  // be inserted.
   EXPECT_EQ(columnSetSignature("mc"), "c");
   destroyLayoutObject("block");
   // There's still some content after the removal, so the set should remain.
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertSpannerAndRemove) {
   setMulticolHTML("<div id='spanner'></div><div id='mc'></div>");
   LayoutMultiColumnFlowThread* flowThread = findFlowThread("mc");
   LayoutBlockFlow* spanner =
       toLayoutBlockFlow(getLayoutObjectByElementId("spanner"));
   LayoutBlockFlow* multicolContainer =
       toLayoutBlockFlow(getLayoutObjectByElementId("mc"));
   spanner->remove();
   multicolContainer->addChild(spanner);
   EXPECT_EQ(spanner->parent(), flowThread);
-  // We should now have a spanner placeholder, since we just moved a spanner into the multicol container.
+  // We should now have a spanner placeholder, since we just moved a spanner
+  // into the multicol container.
   EXPECT_EQ(columnSetSignature(flowThread), "s");
   destroyLayoutObject(spanner);
   EXPECT_EQ(columnSetSignature(flowThread), "");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertTwoSpannersAndRemove) {
   setMulticolHTML(
       "<div id='block'>ee<div class='s'></div><div class='s'></div></div><div "
       "id='mc'></div>");
   reparentLayoutObject("mc", "block");
   EXPECT_EQ(columnSetSignature("mc"), "css");
   destroyLayoutObject("block");
   EXPECT_EQ(columnSetSignature("mc"), "");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertSpannerAfterContentAndRemove) {
   setMulticolHTML("<div id='spanner'></div><div id='mc'><div></div></div>");
   reparentLayoutObject("mc", "spanner");
-  // We should now have a spanner placeholder, since we just moved a spanner into the multicol container.
+  // We should now have a spanner placeholder, since we just moved a spanner
+  // into the multicol container.
   EXPECT_EQ(columnSetSignature("mc"), "cs");
   destroyLayoutObject("spanner");
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertSpannerBeforeContentAndRemove) {
   setMulticolHTML(
       "<div id='spanner'></div><div id='mc'><div "
       "id='columnContent'></div></div>");
   reparentLayoutObject("mc", "spanner", "columnContent");
-  // We should now have a spanner placeholder, since we just moved a spanner into the multicol container.
+  // We should now have a spanner placeholder, since we just moved a spanner
+  // into the multicol container.
   EXPECT_EQ(columnSetSignature("mc"), "sc");
   destroyLayoutObject("spanner");
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 TEST_F(MultiColumnTreeModifyingTest, InsertSpannerBetweenContentAndRemove) {
   setMulticolHTML(
       "<div id='spanner'></div><div id='mc'><div></div><div "
       "id='insertBefore'></div></div>");
   reparentLayoutObject("mc", "spanner", "insertBefore");
-  // Since the spanner was inserted in the middle of column content, what used to be one column
-  // set had to be split in two, in order to get a spot to insert the spanner placeholder.
+  // Since the spanner was inserted in the middle of column content, what used
+  // to be one column set had to be split in two, in order to get a spot to
+  // insert the spanner placeholder.
   EXPECT_EQ(columnSetSignature("mc"), "csc");
   destroyLayoutObject("spanner");
-  // The spanner placeholder should be gone again now, and the two sets be merged into one.
+  // The spanner placeholder should be gone again now, and the two sets be
+  // merged into one.
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 TEST_F(MultiColumnTreeModifyingTest,
        InsertSubtreeWithContentAndSpannerAndRemove) {
   setMulticolHTML(
       "<div id='block'>text<div id='spanner'></div>text</div><div "
       "id='mc'></div>");
   reparentLayoutObject("mc", "block");
   EXPECT_EQ(columnSetSignature("mc"), "csc");
@@ skipping 63 matching lines @@
   EXPECT_EQ(columnSetSignature("mc"), "s");
 }
 
 TEST_F(MultiColumnTreeModifyingTest,
        InsertContentAfterContentBeforeSpannerAndRemove) {
   setMulticolHTML(
       "<div id='block'></div><div id='mc'>text<div id='insertBefore' "
       "class='s'></div></div>");
   EXPECT_EQ(columnSetSignature("mc"), "cs");
   reparentLayoutObject("mc", "block", "insertBefore");
-  // There was already some content before the spanner prior to our insertion, so no new set
-  // should be inserted.
+  // There was already some content before the spanner prior to our insertion,
+  // so no new set should be inserted.
   EXPECT_EQ(columnSetSignature("mc"), "cs");
   destroyLayoutObject("block");
   EXPECT_EQ(columnSetSignature("mc"), "cs");
 }
 
 TEST_F(MultiColumnTreeModifyingTest,
        InsertContentAfterContentAndSpannerAndRemove) {
   setMulticolHTML(
       "<div id='block'></div><div id='mc'>content<div class='s'></div></div>");
   EXPECT_EQ(columnSetSignature("mc"), "cs");
@@ skipping 275 matching lines @@
       "<div id='mc'>text<div id='spanner'><div "
       "class='s'></div></div>text</div>");
   EXPECT_EQ(columnSetSignature("mc"), "csc");
   destroyLayoutObject("spanner");
   EXPECT_EQ(columnSetSignature("mc"), "c");
 }
 
 }  // anonymous namespace
 
 }  // namespace blink