Rewrap comments to 80 columns in Source/platform/graphics/paint/.

third_party/WebKit/Source/platform/graphics/paint/GeometryMapperTest.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 "platform/graphics/paint/GeometryMapper.h"
 
 #include "platform/geometry/GeometryTestHelpers.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
@@ skipping 224 matching lines @@
   TransformationMatrix translateTransform;
   translateTransform.translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, translateTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
-  // Note: unlike NestedTransforms, the order of these transforms matters. This tests correct order of matrix multiplication.
+  // Note: unlike NestedTransforms, the order of these transforms matters. This
+  // tests correct order of matrix multiplication.
   TransformationMatrix final = scaleTransform * translateTransform;
   FloatRect output = final.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, final, rootClipNode->clipRect().rect(),
                  localState, rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(scaleTransform,
             getPrecomputedDataForAncestor(rootPropertyTreeState())
                 .toAncestorTransforms.get(transform1.get()));
@@ skipping 139 matching lines @@
   }
 
   {
     PropertyTreeState localState = rootPropertyTreeState();
     localState.setClip(clip2.get());
     localState.setTransform(transform.get());
 
     FloatRect mappedClip = rotateTransform.mapRect(clip2->clipRect().rect());
     mappedClip.intersect(clip1->clipRect().rect());
 
-    // All clips are performed in the space of the ancestor. In cases such as this, this means the
-    // clip is a bit lossy.
+    // All clips are performed in the space of the ancestor. In cases such as
+    // this, this means the clip is a bit lossy.
     FloatRect output(input);
     // Map to transformed rect in ancestor space.
     output = rotateTransform.mapRect(output);
-    // Intersect with all clips between local and ancestor, independently mapped to ancestor space.
+    // Intersect with all clips between local and ancestor, independently mapped
+    // to ancestor space.
     output.intersect(mappedClip);
 
     CHECK_MAPPINGS(
         input,                           // Input
         output,                          // Visual rect
         rotateTransform.mapRect(input),  // Transformed rect (not clipped)
         rotateTransform,                 // Transform matrix to ancestor space
         mappedClip,                      // Clip rect in ancestor space
         localState, rootPropertyTreeState());
   }
 }
 
 TEST_F(GeometryMapperTest, SiblingTransforms) {
-  // These transforms are siblings. Thus mapping from one to the other requires going through the root.
+  // These transforms are siblings. Thus mapping from one to the other requires
+  // going through the root.
   TransformationMatrix rotateTransform1;
   rotateTransform1.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform1, FloatPoint3D());
 
   TransformationMatrix rotateTransform2;
   rotateTransform2.rotate(-45);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
@@ skipping 37 matching lines @@
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 
   result = geometryMapper->mapRectToDestinationSpace(input, transform1State,
                                                      transform2State, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 }
 
 TEST_F(GeometryMapperTest, SiblingTransformsWithClip) {
-  // These transforms are siblings. Thus mapping from one to the other requires going through the root.
+  // These transforms are siblings. Thus mapping from one to the other requires
+  // going through the root.
   TransformationMatrix rotateTransform1;
   rotateTransform1.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform1, FloatPoint3D());
 
   TransformationMatrix rotateTransform2;
   rotateTransform2.rotate(-45);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform2, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       rootPropertyTreeState().clip(), transform2.get(),
       FloatRoundedRect(10, 10, 70, 70));
 
   PropertyTreeState transform1State = rootPropertyTreeState();
   transform1State.setTransform(transform1.get());
   PropertyTreeState transform2AndClipState = rootPropertyTreeState();
   transform2AndClipState.setTransform(transform2.get());
   transform2AndClipState.setClip(clip.get());
 
   bool success;
   FloatRect input(0, 0, 100, 100);
 
   // Test map from transform1State to transform2AndClipState.
   FloatRect expected =
       rotateTransform2.inverse().mapRect(rotateTransform1.mapRect(input));
 
-  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to destination.
+  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to
+  // destination.
   FloatRect result = geometryMapper->mapToVisualRectInDestinationSpace(
       input, transform1State, transform2AndClipState, success);
-  // Fails, because the clip of the destination state is not an ancestor of the clip of the source state.
+  // Fails, because the clip of the destination state is not an ancestor of the
+  // clip of the source state.
   EXPECT_FALSE(success);
 
   // mapRectToDestinationSpace ignores clip.
   result = geometryMapper->mapRectToDestinationSpace(
       input, transform1State, transform2AndClipState, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expected, result);
 
   // Test map from transform2AndClipState to transform1State.
   FloatRect expectedUnclipped =
       rotateTransform1.inverse().mapRect(rotateTransform2.mapRect(input));
   FloatRect expectedClipped = rotateTransform1.inverse().mapRect(
       rotateTransform2.mapRect(FloatRect(10, 10, 70, 70)));
 
-  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to destination.
+  // mapToVisualRectInDestinationSpace ignores clip from the common ancestor to
+  // destination.
   result = geometryMapper->mapToVisualRectInDestinationSpace(
       input, transform2AndClipState, transform1State, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expectedClipped, result);
 
   // mapRectToDestinationSpace ignores clip.
   result = geometryMapper->mapRectToDestinationSpace(
       input, transform2AndClipState, transform1State, success);
   EXPECT_TRUE(success);
   EXPECT_RECT_EQ(expectedUnclipped, result);
@@ skipping 29 matching lines @@
   EXPECT_EQ(rootPropertyTreeState().transform(),
             leastCommonAncestor(childOfChild2.get(),
                                 rootPropertyTreeState().transform()));
   EXPECT_EQ(child2, leastCommonAncestor(childOfChild2.get(), child2.get()));
 
   EXPECT_EQ(rootPropertyTreeState().transform(),
             leastCommonAncestor(child1.get(), child2.get()));
 }
 
 }  // namespace blink