Reformat comments in core/layout/svg

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

 /*
  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2007, 2008, 2009 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.
  * Copyright (C) Research In Motion Limited 2011. 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
  * License as published by the Free Software Foundation; either
@@ skipping 81 matching lines @@
 }
 
 bool LayoutSVGRoot::isEmbeddedThroughFrameContainingSVGDocument() const {
   if (!node())
     return false;
 
   LocalFrame* frame = node()->document().frame();
   if (!frame)
     return false;
 
-  // If our frame has an owner layoutObject, we're embedded through eg. object/embed/iframe,
-  // but we only negotiate if we're in an SVG document inside a embedded object (object/embed).
+  // If our frame has an owner layoutObject, we're embedded through eg.
+  // object/embed/iframe, but we only negotiate if we're in an SVG document
+  // inside a embedded object (object/embed).
   if (frame->ownerLayoutItem().isNull() ||
       !frame->ownerLayoutItem().isEmbeddedObject())
     return false;
   return frame->document()->isSVGDocument();
 }
 
 LayoutUnit LayoutSVGRoot::computeReplacedLogicalWidth(
     ShouldComputePreferred shouldComputePreferred) const {
-  // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
+  // When we're embedded through SVGImage
+  // (border-image/background-image/<html:img>/...) we're forced to resize to a
+  // specific size.
   if (!m_containerSize.isEmpty())
     return LayoutUnit(m_containerSize.width());
 
   if (isEmbeddedThroughFrameContainingSVGDocument())
     return containingBlock()->availableLogicalWidth();
 
   return LayoutReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
 }
 
 LayoutUnit LayoutSVGRoot::computeReplacedLogicalHeight(
     LayoutUnit estimatedUsedWidth) const {
-  // When we're embedded through SVGImage (border-image/background-image/<html:img>/...) we're forced to resize to a specific size.
+  // When we're embedded through SVGImage
+  // (border-image/background-image/<html:img>/...) we're forced to resize to a
+  // specific size.
   if (!m_containerSize.isEmpty())
     return LayoutUnit(m_containerSize.height());
 
   if (isEmbeddedThroughFrameContainingSVGDocument())
     return containingBlock()->availableLogicalHeight(
         IncludeMarginBorderPadding);
 
   return LayoutReplaced::computeReplacedLogicalHeight(estimatedUsedWidth);
 }
 
@@ skipping 43 matching lines @@
   updateLayerTransformAfterLayout();
   m_hasBoxDecorationBackground = isDocumentElement()
                                      ? styleRef().hasBoxDecorationBackground()
                                      : hasBoxDecorationBackground();
   invalidateBackgroundObscurationStatus();
 
   clearNeedsLayout();
 }
 
 bool LayoutSVGRoot::shouldApplyViewportClip() const {
-  // the outermost svg is clipped if auto, and svg document roots are always clipped
-  // When the svg is stand-alone (isDocumentElement() == true) the viewport clipping should always
-  // be applied, noting that the window scrollbars should be hidden if overflow=hidden.
+  // the outermost svg is clipped if auto, and svg document roots are always
+  // clipped. When the svg is stand-alone (isDocumentElement() == true) the
+  // viewport clipping should always be applied, noting that the window
+  // scrollbars should be hidden if overflow=hidden.
   return style()->overflowX() == OverflowHidden ||
          style()->overflowX() == OverflowAuto ||
          style()->overflowX() == OverflowScroll || this->isDocumentElement();
 }
 
 LayoutRect LayoutSVGRoot::visualOverflowRect() const {
   LayoutRect rect = LayoutReplaced::selfVisualOverflowRect();
   if (!shouldApplyViewportClip())
     rect.unite(contentsVisualOverflowRect());
   return rect;
@@ skipping 127 matching lines @@
       contentWidth() / scale, contentHeight() / scale);
 
   AffineTransform viewToBorderBoxTransform(
       scale, 0, 0, scale, borderAndPadding.width() + translate.x(),
       borderAndPadding.height() + translate.y());
   viewToBorderBoxTransform.scale(svg->currentScale());
   m_localToBorderBoxTransform.preMultiply(viewToBorderBoxTransform);
 }
 
 const AffineTransform& LayoutSVGRoot::localToSVGParentTransform() const {
-  // Slightly optimized version of m_localToParentTransform = AffineTransform::translation(x(), y()) * m_localToBorderBoxTransform;
+  // Slightly optimized version of m_localToParentTransform =
+  // AffineTransform::translation(x(), y()) * m_localToBorderBoxTransform;
   m_localToParentTransform = m_localToBorderBoxTransform;
   if (location().x())
     m_localToParentTransform.setE(m_localToParentTransform.e() +
                                   roundToInt(location().x()));
   if (location().y())
     m_localToParentTransform.setF(m_localToParentTransform.f() +
                                   roundToInt(location().y()));
   return m_localToParentTransform;
 }
 
 LayoutRect LayoutSVGRoot::localOverflowRectForPaintInvalidation() const {
-  // This is an open-coded aggregate of SVGLayoutSupport::localOverflowRectForPaintInvalidation,
-  // and LayoutReplaced::localOverflowRectForPaintInvalidation.
-  // The reason for this is to optimize/minimize the paint invalidation rect when the box is not "decorated"
-  // (does not have background/border/etc., see LayoutSVGRootTest.OverflowRectMappingWithViewportClipWithoutBorder).
+  // This is an open-coded aggregate of SVGLayoutSupport::
+  // localOverflowRectForPaintInvalidation, and LayoutReplaced::
+  // localOverflowRectForPaintInvalidation.
+  // The reason for this is to optimize/minimize the paint invalidation rect
+  // when the box is not "decorated" (does not have background/border/etc., see
+  // LayoutSVGRootTest.OverflowRectMappingWithViewportClipWithoutBorder).
 
   // Return early for any cases where we don't actually paint.
   if (style()->visibility() != EVisibility::Visible &&
       !enclosingLayer()->hasVisibleContent())
     return LayoutRect();
 
-  // Compute the paint invalidation rect of the content of the SVG in the border-box coordinate space.
+  // Compute the paint invalidation rect of the content of the SVG in the
+  // border-box coordinate space.
   FloatRect contentPaintInvalidationRect =
       paintInvalidationRectInLocalSVGCoordinates();
   contentPaintInvalidationRect =
       m_localToBorderBoxTransform.mapRect(contentPaintInvalidationRect);
 
-  // Apply initial viewport clip, overflow:visible content is added to visualOverflow
-  // but the most common case is that overflow is hidden, so always intersect.
+  // Apply initial viewport clip, overflow:visible content is added to
+  // visualOverflow but the most common case is that overflow is hidden, so
+  // always intersect.
   contentPaintInvalidationRect.intersect(pixelSnappedBorderBoxRect());
 
   LayoutRect paintInvalidationRect =
       enclosingLayoutRect(contentPaintInvalidationRect);
-  // If the box is decorated or is overflowing, extend it to include the border-box and overflow.
+  // If the box is decorated or is overflowing, extend it to include the
+  // border-box and overflow.
   if (m_hasBoxDecorationBackground || hasOverflowModel()) {
-    // The selectionRect can project outside of the overflowRect, so take their union
-    // for paint invalidation to avoid selection painting glitches.
+    // The selectionRect can project outside of the overflowRect, so take their
+    // union for paint invalidation to avoid selection painting glitches.
     LayoutRect decoratedPaintInvalidationRect =
         unionRect(localSelectionRect(), visualOverflowRect());
     paintInvalidationRect.unite(decoratedPaintInvalidationRect);
   }
 
   return LayoutRect(enclosingIntRect(paintInvalidationRect));
 }
 
 // This method expects local CSS box coordinates.
-// Callers with local SVG viewport coordinates should first apply the localToBorderBoxTransform
-// to convert from SVG viewport coordinates to local CSS box coordinates.
+// Callers with local SVG viewport coordinates should first apply the
+// localToBorderBoxTransform to convert from SVG viewport coordinates to local
+// CSS box coordinates.
 void LayoutSVGRoot::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                        TransformState& transformState,
                                        MapCoordinatesFlags mode) const {
   LayoutReplaced::mapLocalToAncestor(ancestor, transformState,
                                      mode | ApplyContainerFlip);
 }
 
 const LayoutObject* LayoutSVGRoot::pushMappingToContainer(
     const LayoutBoxModelObject* ancestorToStopAt,
     LayoutGeometryMap& geometryMap) const {
@@ skipping 11 matching lines @@
 bool LayoutSVGRoot::nodeAtPoint(HitTestResult& result,
                                 const HitTestLocation& locationInContainer,
                                 const LayoutPoint& accumulatedOffset,
                                 HitTestAction hitTestAction) {
   LayoutPoint pointInParent =
       locationInContainer.point() - toLayoutSize(accumulatedOffset);
   LayoutPoint pointInBorderBox = pointInParent - toLayoutSize(location());
 
   // Only test SVG content if the point is in our content box, or in case we
   // don't clip to the viewport, the visual overflow rect.
-  // FIXME: This should be an intersection when rect-based hit tests are supported by nodeAtFloatPoint.
+  // FIXME: This should be an intersection when rect-based hit tests are
+  // supported by nodeAtFloatPoint.
   if (contentBoxRect().contains(pointInBorderBox) ||
       (!shouldApplyViewportClip() &&
        visualOverflowRect().contains(pointInBorderBox))) {
     const AffineTransform& localToParentTransform =
         this->localToSVGParentTransform();
     if (localToParentTransform.isInvertible()) {
       FloatPoint localPoint =
           localToParentTransform.inverse().mapPoint(FloatPoint(pointInParent));
 
       for (LayoutObject* child = lastChild(); child;
            child = child->previousSibling()) {
         // FIXME: nodeAtFloatPoint() doesn't handle rect-based hit tests yet.
         if (child->nodeAtFloatPoint(result, localPoint, hitTestAction)) {
           updateHitTestResult(result, pointInBorderBox);
           if (result.addNodeToListBasedTestResult(
                   child->node(), locationInContainer) == StopHitTesting)
             return true;
         }
       }
     }
   }
 
-  // If we didn't early exit above, we've just hit the container <svg> element. Unlike SVG 1.1, 2nd Edition allows container elements to be hit.
+  // If we didn't early exit above, we've just hit the container <svg> element.
+  // Unlike SVG 1.1, 2nd Edition allows container elements to be hit.
   if ((hitTestAction == HitTestBlockBackground ||
        hitTestAction == HitTestChildBlockBackground) &&
       visibleToHitTestRequest(result.hitTestRequest())) {
-    // Only return true here, if the last hit testing phase 'BlockBackground' (or 'ChildBlockBackground' - depending on context) is executed.
-    // If we'd return true in the 'Foreground' phase, hit testing would stop immediately. For SVG only trees this doesn't matter.
-    // Though when we have a <foreignObject> subtree we need to be able to detect hits on the background of a <div> element.
-    // If we'd return true here in the 'Foreground' phase, we are not able to detect these hits anymore.
+    // Only return true here, if the last hit testing phase 'BlockBackground'
+    // (or 'ChildBlockBackground' - depending on context) is executed.
+    // If we'd return true in the 'Foreground' phase, hit testing would stop
+    // immediately. For SVG only trees this doesn't matter.
+    // Though when we have a <foreignObject> subtree we need to be able to
+    // detect hits on the background of a <div> element.
+    // If we'd return true here in the 'Foreground' phase, we are not able to
+    // detect these hits anymore.
     LayoutRect boundsRect(accumulatedOffset + location(), size());
     if (locationInContainer.intersects(boundsRect)) {
       updateHitTestResult(result, pointInBorderBox);
       if (result.addNodeToListBasedTestResult(node(), locationInContainer,
                                               boundsRect) == StopHitTesting)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace blink