Reformat comments in core/layout/svg

third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 40 matching lines @@
       : candidateLayoutObject(nullptr),
         candidateDistance(std::numeric_limits<float>::max()) {}
   SearchCandidate(LayoutObject* layoutObject, float distance)
       : candidateLayoutObject(layoutObject), candidateDistance(distance) {}
   LayoutObject* candidateLayoutObject;
   float candidateDistance;
 };
 
 FloatRect SVGLayoutSupport::localOverflowRectForPaintInvalidation(
     const LayoutObject& object) {
-  // This doesn't apply to LayoutSVGRoot. Use LayoutSVGRoot::localOverflowRectForPaintInvalidation() instead.
+  // This doesn't apply to LayoutSVGRoot. Use
+  // LayoutSVGRoot::localOverflowRectForPaintInvalidation() instead.
   ASSERT(!object.isSVGRoot());
 
   // Return early for any cases where we don't actually paint
   if (object.styleRef().visibility() != EVisibility::Visible &&
       !object.enclosingLayer()->hasVisibleContent())
     return FloatRect();
 
   FloatRect paintInvalidationRect =
       object.paintInvalidationRectInLocalSVGCoordinates();
   if (int outlineOutset = object.styleRef().outlineOutsetExtent())
@@ skipping 13 matching lines @@
 
 LayoutRect SVGLayoutSupport::transformPaintInvalidationRect(
     const LayoutObject& object,
     const AffineTransform& rootTransform,
     const FloatRect& localRect) {
   FloatRect adjustedRect = rootTransform.mapRect(localRect);
 
   if (object.isSVGShape() && object.styleRef().svgStyle().hasStroke()) {
     if (float strokeWidthForHairlinePadding =
             toLayoutSVGShape(object).strokeWidth()) {
-      // For hairline strokes (stroke-width < 1 in device space), Skia rasterizes up to 0.4(9) off
-      // the stroke center. That means enclosingIntRect is not enough - we must also pad to 0.5.
+      // For hairline strokes (stroke-width < 1 in device space), Skia
+      // rasterizes up to 0.4(9) off the stroke center. That means
+      // enclosingIntRect is not enough - we must also pad to 0.5.
       // This is still fragile as it misses out on CC/DSF CTM components.
       const FloatSize strokeSize = rootTransform.mapSize(FloatSize(
           strokeWidthForHairlinePadding, strokeWidthForHairlinePadding));
       if (strokeSize.width() < 1 || strokeSize.height() < 1) {
         float pad =
             0.5f - std::min(strokeSize.width(), strokeSize.height()) / 2;
         DCHECK_GT(pad, 0);
-        // Additionally, square/round caps can potentially introduce an outset <= 0.5
+        // Additionally, square/round caps can potentially introduce an outset
+        // <= 0.5
         if (object.styleRef().svgStyle().capStyle() != ButtCap)
           pad += 0.5f;
         adjustedRect.inflate(pad);
       }
     }
   }
 
   if (adjustedRect.isEmpty())
     return LayoutRect();
 
@@ skipping 41 matching lines @@
 }
 
 void SVGLayoutSupport::mapLocalToAncestor(const LayoutObject* object,
                                           const LayoutBoxModelObject* ancestor,
                                           TransformState& transformState,
                                           MapCoordinatesFlags flags) {
   transformState.applyTransform(object->localToSVGParentTransform());
 
   LayoutObject* parent = object->parent();
 
-  // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
-  // to map an element from SVG viewport coordinates to CSS box coordinates.
+  // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the
+  // localToBorderBoxTransform to map an element from SVG viewport coordinates
+  // to CSS box coordinates.
   // LayoutSVGRoot's mapLocalToAncestor method expects CSS box coordinates.
   if (parent->isSVGRoot())
     transformState.applyTransform(
         toLayoutSVGRoot(parent)->localToBorderBoxTransform());
 
   parent->mapLocalToAncestor(ancestor, transformState, flags);
 }
 
 void SVGLayoutSupport::mapAncestorToLocal(const LayoutObject& object,
                                           const LayoutBoxModelObject* ancestor,
@@ skipping 17 matching lines @@
 }
 
 const LayoutObject* SVGLayoutSupport::pushMappingToContainer(
     const LayoutObject* object,
     const LayoutBoxModelObject* ancestorToStopAt,
     LayoutGeometryMap& geometryMap) {
   DCHECK_NE(ancestorToStopAt, object);
 
   LayoutObject* parent = object->parent();
 
-  // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
-  // to map an element from SVG viewport coordinates to CSS box coordinates.
+  // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the
+  // localToBorderBoxTransform to map an element from SVG viewport coordinates
+  // to CSS box coordinates.
   // LayoutSVGRoot's mapLocalToAncestor method expects CSS box coordinates.
   if (parent->isSVGRoot()) {
     TransformationMatrix matrix(object->localToSVGParentTransform());
     matrix.multiply(toLayoutSVGRoot(parent)->localToBorderBoxTransform());
     geometryMap.push(object, matrix);
   } else {
     geometryMap.push(object, object->localToSVGParentTransform());
   }
 
   return parent;
 }
 
-// Update a bounding box taking into account the validity of the other bounding box.
+// Update a bounding box taking into account the validity of the other bounding
+// box.
 inline void SVGLayoutSupport::updateObjectBoundingBox(
     FloatRect& objectBoundingBox,
     bool& objectBoundingBoxValid,
     LayoutObject* other,
     FloatRect otherBoundingBox) {
   bool otherValid =
       other->isSVGContainer()
           ? toLayoutSVGContainer(other)->isObjectBoundingBoxValid()
           : true;
   if (!otherValid)
@@ skipping 11 matching lines @@
 void SVGLayoutSupport::computeContainerBoundingBoxes(
     const LayoutObject* container,
     FloatRect& objectBoundingBox,
     bool& objectBoundingBoxValid,
     FloatRect& strokeBoundingBox,
     FloatRect& paintInvalidationBoundingBox) {
   objectBoundingBox = FloatRect();
   objectBoundingBoxValid = false;
   strokeBoundingBox = FloatRect();
 
-  // When computing the strokeBoundingBox, we use the paintInvalidationRects of the container's children so that the container's stroke includes
-  // the resources applied to the children (such as clips and filters). This allows filters applied to containers to correctly bound
-  // the children, and also improves inlining of SVG content, as the stroke bound is used in that situation also.
+  // When computing the strokeBoundingBox, we use the paintInvalidationRects of
+  // the container's children so that the container's stroke includes the
+  // resources applied to the children (such as clips and filters). This allows
+  // filters applied to containers to correctly bound the children, and also
+  // improves inlining of SVG content, as the stroke bound is used in that
+  // situation also.
   for (LayoutObject* current = container->slowFirstChild(); current;
        current = current->nextSibling()) {
     if (current->isSVGHiddenContainer())
       continue;
 
     // Don't include elements in the union that do not layout.
     if (current->isSVGShape() && toLayoutSVGShape(current)->isShapeEmpty())
       continue;
 
     if (current->isSVGText() &&
@@ skipping 56 matching lines @@
 
     if (screenScalingFactorChanged) {
       // If the screen scaling factor changed we need to update the text
       // metrics (note: this also happens for layoutSizeChanged=true).
       if (child->isSVGText())
         toLayoutSVGText(child)->setNeedsTextMetricsUpdate();
       forceChildLayout = true;
     }
 
     if (layoutSizeChanged) {
-      // When selfNeedsLayout is false and the layout size changed, we have to check whether this child uses relative lengths
+      // When selfNeedsLayout is false and the layout size changed, we have to
+      // check whether this child uses relative lengths
       if (SVGElement* element =
               child->node()->isSVGElement() ? toSVGElement(child->node()) : 0) {
         if (element->hasRelativeLengths()) {
           // FIXME: this should be done on invalidation, not during layout.
-          // When the layout size changed and when using relative values tell the LayoutSVGShape to update its shape object
+          // When the layout size changed and when using relative values tell
+          // the LayoutSVGShape to update its shape object
           if (child->isSVGShape()) {
             toLayoutSVGShape(child)->setNeedsShapeUpdate();
           } else if (child->isSVGText()) {
             toLayoutSVGText(child)->setNeedsTextMetricsUpdate();
             toLayoutSVGText(child)->setNeedsPositioningValuesUpdate();
           }
 
           forceChildLayout = true;
         }
       }
     }
 
-    // Resource containers are nasty: they can invalidate clients outside the current SubtreeLayoutScope.
-    // Since they only care about viewport size changes (to resolve their relative lengths), we trigger
-    // their invalidation directly from SVGSVGElement::svgAttributeChange() or at a higher
-    // SubtreeLayoutScope (in LayoutView::layout()). We do not create a SubtreeLayoutScope for
-    // resources because their ability to reference each other leads to circular layout. We protect
-    // against that within the layout code for resources, but it causes assertions if we use a
-    // SubTreeLayoutScope for them.
+    // Resource containers are nasty: they can invalidate clients outside the
+    // current SubtreeLayoutScope.
+    // Since they only care about viewport size changes (to resolve their
+    // relative lengths), we trigger their invalidation directly from
+    // SVGSVGElement::svgAttributeChange() or at a higher SubtreeLayoutScope (in
+    // LayoutView::layout()). We do not create a SubtreeLayoutScope for
+    // resources because their ability to reference each other leads to circular
+    // layout. We protect against that within the layout code for resources, but
+    // it causes assertions if we use a SubTreeLayoutScope for them.
     if (child->isSVGResourceContainer()) {
       // Lay out any referenced resources before the child.
       layoutResourcesIfNeeded(child);
       child->layoutIfNeeded();
     } else {
       SubtreeLayoutScope layoutScope(*child);
       if (forceChildLayout)
         layoutScope.setNeedsLayout(child, LayoutInvalidationReason::SvgChanged);
 
       // Lay out any referenced resources before the child.
       layoutResourcesIfNeeded(child);
       child->layoutIfNeeded();
     }
   }
 }
 
 void SVGLayoutSupport::layoutResourcesIfNeeded(const LayoutObject* object) {
   ASSERT(object);
 
   SVGResources* resources =
       SVGResourcesCache::cachedResourcesForLayoutObject(object);
   if (resources)
     resources->layoutIfNeeded();
 }
 
 bool SVGLayoutSupport::isOverflowHidden(const LayoutObject* object) {
-  // LayoutSVGRoot should never query for overflow state - it should always clip itself to the initial viewport size.
+  // LayoutSVGRoot should never query for overflow state - it should always clip
+  // itself to the initial viewport size.
   ASSERT(!object->isDocumentElement());
 
   return object->style()->overflowX() == OverflowHidden ||
          object->style()->overflowX() == OverflowScroll;
 }
 
 void SVGLayoutSupport::intersectPaintInvalidationRectWithResources(
     const LayoutObject* layoutObject,
     FloatRect& paintInvalidationRect) {
   ASSERT(layoutObject);
@@ skipping 140 matching lines @@
   AffineTransform transform;
   while (layoutObject) {
     transform = layoutObject->localToSVGParentTransform() * transform;
     if (layoutObject->isSVGRoot())
       break;
     layoutObject = layoutObject->parent();
   }
 
   // Continue walking up the layer tree, accumulating CSS transforms.
   // FIXME: this queries layer compositing state - which is not
-  // supported during layout. Hence, the result may not include all CSS transforms.
+  // supported during layout. Hence, the result may not include all CSS
+  // transforms.
   PaintLayer* layer = layoutObject ? layoutObject->enclosingLayer() : 0;
   while (layer && layer->isAllowedToQueryCompositingState()) {
     // We can stop at compositing layers, to match the backing resolution.
-    // FIXME: should we be computing the transform to the nearest composited layer,
-    // or the nearest composited layer that does not paint into its ancestor?
-    // I think this is the nearest composited ancestor since we will inherit its
-    // transforms in the composited layer tree.
+    // FIXME: should we be computing the transform to the nearest composited
+    // layer, or the nearest composited layer that does not paint into its
+    // ancestor? I think this is the nearest composited ancestor since we will
+    // inherit its transforms in the composited layer tree.
     if (layer->compositingState() != NotComposited)
       break;
 
     if (TransformationMatrix* layerTransform = layer->transform())
       transform = layerTransform->toAffineTransform() * transform;
 
     layer = layer->parent();
   }
 
   return transform;
 }
 
 float SVGLayoutSupport::calculateScreenFontSizeScalingFactor(
     const LayoutObject* layoutObject) {
   ASSERT(layoutObject);
 
-  // FIXME: trying to compute a device space transform at record time is wrong. All clients
-  // should be updated to avoid relying on this information, and the method should be removed.
+  // FIXME: trying to compute a device space transform at record time is wrong.
+  // All clients should be updated to avoid relying on this information, and the
+  // method should be removed.
   AffineTransform ctm =
       deprecatedCalculateTransformToLayer(layoutObject) *
       SubtreeContentTransformScope::currentContentTransformation();
   ctm.scale(
       layoutObject->document().frameHost()->deviceScaleFactorDeprecated());
 
   return clampTo<float>(sqrt((ctm.xScaleSquared() + ctm.yScaleSquared()) / 2));
 }
 
 static inline bool compareCandidateDistance(const SearchCandidate& r1,
@@ skipping 42 matching lines @@
 
   // If a LayoutSVGText was found and there are no potentially closer sub-trees,
   // just return |closestText|.
   if (closestText.candidateLayoutObject && candidates.isEmpty())
     return closestText;
 
   std::stable_sort(candidates.begin(), candidates.end(),
                    compareCandidateDistance);
 
   // Find the closest LayoutSVGText in the sub-trees in |candidates|.
-  // If a LayoutSVGText is found that is strictly closer than any previous candidate, then end the search.
+  // If a LayoutSVGText is found that is strictly closer than any previous
+  // candidate, then end the search.
   for (const SearchCandidate& searchCandidate : candidates) {
     if (closestText.candidateDistance < searchCandidate.candidateDistance)
       break;
     LayoutObject* candidateLayoutObject = searchCandidate.candidateLayoutObject;
     FloatPoint candidateLocalPoint =
         candidateLayoutObject->localToSVGParentTransform().inverse().mapPoint(
             point);
 
     SearchCandidate candidateText = searchTreeForFindClosestLayoutSVGText(
         candidateLayoutObject, candidateLocalPoint);
 
     if (candidateText.candidateDistance < closestText.candidateDistance)
       closestText = candidateText;
   }
 
   return closestText;
 }
 
 LayoutObject* SVGLayoutSupport::findClosestLayoutSVGText(
     LayoutObject* layoutObject,
     const FloatPoint& point) {
   return searchTreeForFindClosestLayoutSVGText(layoutObject, point)
       .candidateLayoutObject;
 }
 
 }  // namespace blink