reflow comments in core/layout/[M-Z]*.{cpp,h}

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

 // Copyright 2016 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/LayoutInline.h"
 #include "core/layout/LayoutTestHelper.h"
 #include "core/layout/LayoutView.h"
 #include "platform/geometry/TransformState.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 14 matching lines @@
   FloatPoint mapAncestorToLocal(const LayoutObject*,
                                 const LayoutBoxModelObject* ancestor,
                                 FloatPoint,
                                 MapCoordinatesFlags = 0) const;
   FloatQuad mapAncestorToLocal(const LayoutObject*,
                                const LayoutBoxModelObject* ancestor,
                                FloatQuad,
                                MapCoordinatesFlags = 0) const;
 };
 
-// One note about tests here that operate on LayoutInline and LayoutText objects:
-// mapLocalToAncestor() expects such objects to pass their static location and size (relatively to
-// the border edge of their container) to mapLocalToAncestor() via the TransformState
-// argument. mapLocalToAncestor() is then only expected to make adjustments for
-// relative-positioning, container-specific characteristics (such as writing mode roots, multicol),
-// and so on. This in contrast to LayoutBox objects, where the TransformState passed is relative to
-// the box itself, not the container.
+// One note about tests here that operate on LayoutInline and LayoutText
+// objects: mapLocalToAncestor() expects such objects to pass their static
+// location and size (relatively to the border edge of their container) to
+// mapLocalToAncestor() via the TransformState argument. mapLocalToAncestor() is
+// then only expected to make adjustments for relative-positioning,
+// container-specific characteristics (such as writing mode roots, multicol),
+// and so on. This in contrast to LayoutBox objects, where the TransformState
+// passed is relative to the box itself, not the container.
 
 FloatPoint MapCoordinatesTest::mapLocalToAncestor(
     const LayoutObject* object,
     const LayoutBoxModelObject* ancestor,
     FloatPoint point,
     MapCoordinatesFlags mode) const {
   TransformState transformState(TransformState::ApplyTransformDirection, point);
   object->mapLocalToAncestor(ancestor, transformState, mode);
   transformState.flatten();
   return transformState.lastPlanarPoint();
@@ skipping 543 matching lines @@
                                      ProgrammaticScroll);
   document().view()->updateAllLifecyclePhases();
 
   Element* target = frameDocument.getElementById("target");
   ASSERT_TRUE(target);
   FloatPoint mappedPoint =
       mapAncestorToLocal(target->layoutObject(), nullptr, FloatPoint(10, 70),
                          TraverseDocumentBoundaries);
 
   // y = 70 - 8000, since the iframe is offset by 8000px from the main frame.
-  // The scroll is not taken into account because the element is not fixed to the root LayoutView,
-  // and the space of the root LayoutView does not include scroll.
+  // The scroll is not taken into account because the element is not fixed to
+  // the root LayoutView, and the space of the root LayoutView does not include
+  // scroll.
   EXPECT_EQ(FloatPoint(10, -7930), mappedPoint);
 }
 
 TEST_F(MapCoordinatesTest, IFrameTransformed) {
   document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com"));
   setBodyInnerHTML(
       "<style>body { margin: 0; }</style>"
       "<iframe style='transform: scale(2)' id=frame src='http://test.com' "
       "width='500' height='500' frameBorder='0'>"
       "</iframe>");
 
   Document& frameDocument =
       setupChildIframe("frame",
                        "<style>body { margin: 0; } #target { width: 200px; "
                        "height: 8000px}</style><div id=target></div>");
 
   document().view()->updateAllLifecyclePhases();
 
   frameDocument.view()->setScrollOffset(ScrollOffset(0.0, 1000),
                                         ProgrammaticScroll);
   frameDocument.view()->updateAllLifecyclePhases();
 
   Element* target = frameDocument.getElementById("target");
   ASSERT_TRUE(target);
   FloatPoint mappedPoint =
       mapAncestorToLocal(target->layoutObject(), nullptr, FloatPoint(200, 200),
                          TraverseDocumentBoundaries | UseTransforms);
 
   // Derivation:
-  // (200, 200) -> (-50, -50)  (Adjust for transform origin of scale, which is at the center of the 500x500 iframe)
+  // (200, 200) -> (-50, -50)  (Adjust for transform origin of scale, which is
+  //                           at the center of the 500x500 iframe)
   // (-50, -50) -> (-25, -25)  (Divide by 2 to invert the scale)
   // (-25, -25) -> (225, 225)  (Add the origin back in)
   // (225, 225) -> (225, 1225) (Adjust by scroll offset of y=1000)
   EXPECT_EQ(FloatPoint(225, 1225), mappedPoint);
 }
 
 TEST_F(MapCoordinatesTest, FixedPosInScrolledIFrameWithTransform) {
   document().setBaseURLOverride(KURL(ParsedURLString, "http://test.com"));
   setBodyInnerHTML(
       "<style>* { margin: 0; }</style>"
@@ skipping 210 matching lines @@
       "padding:7px;'>"
       "        <div style='height:110px;'></div>"
       "        <div id='target' style='position:absolute; left:-1px; top:-1px; "
       "margin:10px; border:13px; padding:13px;'></div>"
       "    </div>"
       "</div>");
 
   LayoutBox* target = toLayoutBox(getLayoutObjectByElementId("target"));
   LayoutBox* container = toLayoutBox(getLayoutObjectByElementId("container"));
 
-  // The multicol container isn't in the containing block chain of the abspos #target.
+  // The multicol container isn't in the containing block chain of the abspos
+  // #target.
   FloatPoint mappedPoint = mapLocalToAncestor(target, container, FloatPoint());
   EXPECT_EQ(FloatPoint(16, 16), mappedPoint);
   mappedPoint = mapAncestorToLocal(target, container, mappedPoint);
   EXPECT_EQ(FloatPoint(), mappedPoint);
 
   // Walk each ancestor in the chain separately, to verify each step on the way.
   LayoutBox* multicol = toLayoutBox(getLayoutObjectByElementId("multicol"));
   LayoutBox* flowThread = target->parentBox();
   ASSERT_TRUE(flowThread->isLayoutFlowThread());
 
@@ skipping 31 matching lines @@
   ASSERT_TRUE(text->isText());
 
   // Map to the nearest container. Flipping should occur.
   FloatPoint mappedPoint = mapLocalToAncestor(
       text, text->containingBlock(), FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(125, 10), mappedPoint);
   mappedPoint = mapAncestorToLocal(text, text->containingBlock(), mappedPoint,
                                    ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
-  // Map to a container further up in the tree. Flipping should still occur on the nearest
-  // container. LayoutObject::mapLocalToAncestor() is called recursively until the ancestor is
-  // reached, and the ApplyContainerFlip flag is cleared after having processed the innermost
-  // object.
+  // Map to a container further up in the tree. Flipping should still occur on
+  // the nearest container. LayoutObject::mapLocalToAncestor() is called
+  // recursively until the ancestor is reached, and the ApplyContainerFlip flag
+  // is cleared after having processed the innermost object.
   mappedPoint =
       mapLocalToAncestor(text, text->containingBlock()->containingBlock(),
                          FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(130, 10), mappedPoint);
   mappedPoint =
       mapAncestorToLocal(text, text->containingBlock()->containingBlock(),
                          mappedPoint, ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
-  // If the ApplyContainerFlip flag isn't specified, no flipping should take place.
+  // If the ApplyContainerFlip flag isn't specified, no flipping should take
+  // place.
   mappedPoint = mapLocalToAncestor(
       text, text->containingBlock()->containingBlock(), FloatPoint(75, 10));
   EXPECT_EQ(FloatPoint(80, 10), mappedPoint);
   mappedPoint = mapAncestorToLocal(
       text, text->containingBlock()->containingBlock(), mappedPoint);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 }
 
 TEST_F(MapCoordinatesTest, FlippedBlocksWritingModeWithInline) {
   setBodyInnerHTML(
       "<div style='-webkit-writing-mode:vertical-rl;'>"
       "    <div style='width:13px;'></div>"
       "    <div style='width:200px; height:400px; line-height:50px;'>"
       "        <span>"
       "            <span id='target'><br>text</span>"
       "        </span>"
       "    </div>"
       "    <div style='width:7px;'></div>"
       "</div>");
 
   LayoutObject* target = getLayoutObjectByElementId("target");
   ASSERT_TRUE(target);
 
-  // First map to the parent SPAN. Nothing special should happen, since flipping occurs at the nearest container.
+  // First map to the parent SPAN. Nothing special should happen, since flipping
+  // occurs at the nearest container.
   FloatPoint mappedPoint =
       mapLocalToAncestor(target, toLayoutBoxModelObject(target->parent()),
                          FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
   mappedPoint =
       mapAncestorToLocal(target, toLayoutBoxModelObject(target->parent()),
                          mappedPoint, ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
   // Continue to the nearest container. Flipping should occur.
   mappedPoint = mapLocalToAncestor(toLayoutBoxModelObject(target->parent()),
                                    target->containingBlock(),
                                    FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(125, 10), mappedPoint);
   mappedPoint = mapAncestorToLocal(toLayoutBoxModelObject(target->parent()),
                                    target->containingBlock(), mappedPoint,
                                    ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
   // Now map from the innermost inline to the nearest container in one go.
   mappedPoint = mapLocalToAncestor(target, target->containingBlock(),
                                    FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(125, 10), mappedPoint);
   mappedPoint = mapAncestorToLocal(target, target->containingBlock(),
                                    mappedPoint, ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
-  // Map to a container further up in the tree. Flipping should still only occur on the nearest container.
+  // Map to a container further up in the tree. Flipping should still only occur
+  // on the nearest container.
   mappedPoint =
       mapLocalToAncestor(target, target->containingBlock()->containingBlock(),
                          FloatPoint(75, 10), ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(132, 10), mappedPoint);
   mappedPoint =
       mapAncestorToLocal(target, target->containingBlock()->containingBlock(),
                          mappedPoint, ApplyContainerFlip);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 
-  // If the ApplyContainerFlip flag isn't specified, no flipping should take place.
+  // If the ApplyContainerFlip flag isn't specified, no flipping should take
+  // place.
   mappedPoint = mapLocalToAncestor(
       target, target->containingBlock()->containingBlock(), FloatPoint(75, 10));
   EXPECT_EQ(FloatPoint(82, 10), mappedPoint);
   mappedPoint = mapAncestorToLocal(
       target, target->containingBlock()->containingBlock(), mappedPoint);
   EXPECT_EQ(FloatPoint(75, 10), mappedPoint);
 }
 
 TEST_F(MapCoordinatesTest, FlippedBlocksWritingModeWithBlock) {
   setBodyInnerHTML(
@@ skipping 415 matching lines @@
       "      <div id='child2'></div>"
       "    </div>"
       "  </div>"
       "</div>");
   LayoutObject* child1 = getLayoutObjectByElementId("child1");
   LayoutObject* child2 = getLayoutObjectByElementId("child2");
   TransformationMatrix matrix;
 
   matrix = child1->localToAbsoluteTransform();
 
-  // With child1, the rotations cancel and points should map basically back to themselves.
+  // With child1, the rotations cancel and points should map basically back to
+  // themselves.
   EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).x(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).y(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).x(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).y(),
               LayoutUnit::epsilon());
 
-  // With child2, each rotation gets flattened and the end result is approximately a 90-degree rotation.
+  // With child2, each rotation gets flattened and the end result is
+  // approximately a 90-degree rotation.
   matrix = child2->localToAbsoluteTransform();
   EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).x(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(50.0, matrix.projectPoint(FloatPoint(100.0, 50.0)).y(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(25.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).x(),
               LayoutUnit::epsilon());
   EXPECT_NEAR(100.0, matrix.projectPoint(FloatPoint(50.0, 100.0)).y(),
               LayoutUnit::epsilon());
 }
 
 }  // namespace blink