reflow comments in core/paint

third_party/WebKit/Source/core/paint/SVGInlineTextBoxPainter.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/paint/SVGInlineTextBoxPainter.h"
 
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/markers/RenderedDocumentMarker.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 11 matching lines @@
 #include "core/paint/PaintInfo.h"
 #include "core/paint/SVGPaintContext.h"
 #include "core/style/ShadowList.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include <memory>
 
 namespace blink {
 
 static inline bool textShouldBePainted(
     const LayoutSVGInlineText& textLayoutObject) {
-  // Font::pixelSize(), returns FontDescription::computedPixelSize(), which returns "int(x + 0.5)".
-  // If the absolute font size on screen is below x=0.5, don't render anything.
+  // Font::pixelSize(), returns FontDescription::computedPixelSize(), which
+  // returns "int(x + 0.5)".  If the absolute font size on screen is below
+  // x=0.5, don't render anything.
   return textLayoutObject.scaledFont().getFontDescription().computedPixelSize();
 }
 
 bool SVGInlineTextBoxPainter::shouldPaintSelection(
     const PaintInfo& paintInfo) const {
   return !paintInfo.isPrinting() &&
          m_svgInlineTextBox.getSelectionState() != SelectionNone;
 }
 
 static bool hasShadow(const PaintInfo& paintInfo, const ComputedStyle& style) {
   // Text shadows are disabled when printing. http://crbug.com/258321
   return style.textShadow() && !paintInfo.isPrinting();
 }
 
 FloatRect SVGInlineTextBoxPainter::boundsForDrawingRecorder(
     const PaintInfo& paintInfo,
     const ComputedStyle& style,
     const LayoutPoint& paintOffset,
     bool includeSelectionRect) const {
-  // We compute the paint rect with what looks like the logical values, to match the
-  // computation in SVGInlineTextBox::calculateBoundaries, and the fact that vertical (etc)
-  // layouts are handled by SVGTextLayoutEngine.
+  // We compute the paint rect with what looks like the logical values, to match
+  // the computation in SVGInlineTextBox::calculateBoundaries, and the fact that
+  // vertical (etc) layouts are handled by SVGTextLayoutEngine.
   LayoutRect bounds(LayoutPoint(m_svgInlineTextBox.topLeft() + paintOffset),
                     LayoutSize(m_svgInlineTextBox.logicalWidth(),
                                m_svgInlineTextBox.logicalHeight()));
   if (hasShadow(paintInfo, style))
     bounds.expand(style.textShadow()->rectOutsetsIncludingOriginal());
   if (includeSelectionRect) {
     bounds.unite(m_svgInlineTextBox.localSelectionRect(
         m_svgInlineTextBox.start(),
         m_svgInlineTextBox.start() + m_svgInlineTextBox.len()));
   }
@@ skipping 18 matching lines @@
                                     const LayoutPoint& paintOffset) {
   ASSERT(paintInfo.phase == PaintPhaseForeground ||
          paintInfo.phase == PaintPhaseSelection);
   ASSERT(m_svgInlineTextBox.truncation() == cNoTruncation);
 
   if (m_svgInlineTextBox.getLineLayoutItem().style()->visibility() !=
           EVisibility::Visible ||
       !m_svgInlineTextBox.len())
     return;
 
-  // We're explicitly not supporting composition & custom underlines and custom highlighters -- unlike InlineTextBox.
-  // If we ever need that for SVG, it's very easy to refactor and reuse the code.
+  // We're explicitly not supporting composition & custom underlines and custom
+  // highlighters -- unlike InlineTextBox.  If we ever need that for SVG, it's
+  // very easy to refactor and reuse the code.
 
   bool haveSelection = shouldPaintSelection(paintInfo);
   if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
     return;
 
   LayoutSVGInlineText& textLayoutObject = inlineText();
   if (!textShouldBePainted(textLayoutObject))
     return;
 
   DisplayItem::Type displayItemType =
@@ skipping 58 matching lines @@
   unsigned textFragmentsSize = m_svgInlineTextBox.textFragments().size();
   for (unsigned i = 0; i < textFragmentsSize; ++i) {
     const SVGTextFragment& fragment = m_svgInlineTextBox.textFragments().at(i);
 
     GraphicsContextStateSaver stateSaver(paintInfo.context, false);
     if (fragment.isTransformed()) {
       stateSaver.save();
       paintInfo.context.concatCTM(fragment.buildFragmentTransform());
     }
 
-    // Spec: All text decorations except line-through should be drawn before the text is filled and stroked; thus, the text is rendered on top of these decorations.
+    // Spec: All text decorations except line-through should be drawn before the
+    // text is filled and stroked; thus, the text is rendered on top of these
+    // decorations.
     unsigned decorations = style.textDecorationsInEffect();
     if (decorations & TextDecorationUnderline)
       paintDecoration(paintInfo, TextDecorationUnderline, fragment);
     if (decorations & TextDecorationOverline)
       paintDecoration(paintInfo, TextDecorationOverline, fragment);
 
     for (int i = 0; i < 3; i++) {
       switch (svgStyle.paintOrderType(i)) {
         case PT_FILL:
           if (hasFill)
             paintText(paintInfo, style, *selectionStyle, fragment,
                       ApplyToFillMode, shouldPaintSelection);
           break;
         case PT_STROKE:
           if (hasVisibleStroke)
             paintText(paintInfo, style, *selectionStyle, fragment,
                       ApplyToStrokeMode, shouldPaintSelection);
           break;
         case PT_MARKERS:
           // Markers don't apply to text
           break;
         default:
           ASSERT_NOT_REACHED();
           break;
       }
     }
 
-    // Spec: Line-through should be drawn after the text is filled and stroked; thus, the line-through is rendered on top of the text.
+    // Spec: Line-through should be drawn after the text is filled and stroked;
+    // thus, the line-through is rendered on top of the text.
     if (decorations & TextDecorationLineThrough)
       paintDecoration(paintInfo, TextDecorationLineThrough, fragment);
   }
 }
 
 void SVGInlineTextBoxPainter::paintSelectionBackground(
     const PaintInfo& paintInfo) {
   if (m_svgInlineTextBox.getLineLayoutItem().style()->visibility() !=
       EVisibility::Visible)
     return;
@@ skipping 30 matching lines @@
     paintInfo.context.setFillColor(backgroundColor);
     paintInfo.context.fillRect(m_svgInlineTextBox.selectionRectForTextFragment(
                                    fragment, fragmentWithRange.startPosition,
                                    fragmentWithRange.endPosition, style),
                                backgroundColor);
   }
 }
 
 static inline LayoutObject* findLayoutObjectDefininingTextDecoration(
     InlineFlowBox* parentBox) {
-  // Lookup first layout object in parent hierarchy which has text-decoration set.
+  // Lookup first layout object in parent hierarchy which has text-decoration
+  // set.
   LayoutObject* layoutObject = nullptr;
   while (parentBox) {
     layoutObject =
         LineLayoutAPIShim::layoutObjectFrom(parentBox->getLineLayoutItem());
 
     if (layoutObject->style() &&
         layoutObject->style()->getTextDecoration() != TextDecorationNone)
       break;
 
     parentBox = parentBox->parent();
   }
 
   ASSERT(layoutObject);
   return layoutObject;
 }
 
-// Offset from the baseline for |decoration|. Positive offsets are above the baseline.
+// Offset from the baseline for |decoration|. Positive offsets are above the
+// baseline.
 static inline float baselineOffsetForDecoration(TextDecoration decoration,
                                                 const FontMetrics& fontMetrics,
                                                 float thickness) {
-  // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
+  // FIXME: For SVG Fonts we need to use the attributes defined in the
+  // <font-face> if specified.
   // Compatible with Batik/Presto.
   if (decoration == TextDecorationUnderline)
     return -thickness * 1.5f;
   if (decoration == TextDecorationOverline)
     return fontMetrics.floatAscent() - thickness;
   if (decoration == TextDecorationLineThrough)
     return fontMetrics.floatAscent() * 3 / 8.0f;
 
   ASSERT_NOT_REACHED();
   return 0.0f;
 }
 
 static inline float thicknessForDecoration(TextDecoration, const Font& font) {
-  // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
+  // FIXME: For SVG Fonts we need to use the attributes defined in the
+  // <font-face> if specified.
   // Compatible with Batik/Presto
   return font.getFontDescription().computedSize() / 20.0f;
 }
 
 void SVGInlineTextBoxPainter::paintDecoration(const PaintInfo& paintInfo,
                                               TextDecoration decoration,
                                               const SVGTextFragment& fragment) {
   if (m_svgInlineTextBox.getLineLayoutItem()
           .style()
           ->textDecorationsInEffect() == TextDecorationNone)
     return;
 
   if (fragment.width <= 0)
     return;
 
-  // Find out which style defined the text-decoration, as its fill/stroke properties have to be used for drawing instead of ours.
+  // Find out which style defined the text-decoration, as its fill/stroke
+  // properties have to be used for drawing instead of ours.
   LayoutObject* decorationLayoutObject =
       findLayoutObjectDefininingTextDecoration(m_svgInlineTextBox.parent());
   const ComputedStyle& decorationStyle = decorationLayoutObject->styleRef();
 
   if (decorationStyle.visibility() != EVisibility::Visible)
     return;
 
   float scalingFactor = 1;
   Font scaledFont;
   LayoutSVGInlineText::computeNewScaledFontForStyle(decorationLayoutObject,
@@ skipping 139 matching lines @@
                                         bool shouldPaintSelection) {
   int startPosition = 0;
   int endPosition = 0;
   if (shouldPaintSelection) {
     m_svgInlineTextBox.selectionStartEnd(startPosition, endPosition);
     shouldPaintSelection =
         m_svgInlineTextBox.mapStartEndPositionsIntoFragmentCoordinates(
             fragment, startPosition, endPosition);
   }
 
-  // Fast path if there is no selection, just draw the whole chunk part using the regular style
+  // Fast path if there is no selection, just draw the whole chunk part using
+  // the regular style.
   TextRun textRun = m_svgInlineTextBox.constructTextRun(style, fragment);
   if (!shouldPaintSelection || startPosition >= endPosition) {
     SkPaint paint;
     if (setupTextPaint(paintInfo, style, resourceMode, paint))
       paintText(paintInfo, textRun, fragment, 0, fragment.length, paint);
     return;
   }
 
-  // Eventually draw text using regular style until the start position of the selection
+  // Eventually draw text using regular style until the start position of the
+  // selection.
   bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
   if (startPosition > 0 && !paintSelectedTextOnly) {
     SkPaint paint;
     if (setupTextPaint(paintInfo, style, resourceMode, paint))
       paintText(paintInfo, textRun, fragment, 0, startPosition, paint);
   }
 
-  // Draw text using selection style from the start to the end position of the selection
+  // Draw text using selection style from the start to the end position of the
+  // selection.
   if (style != selectionStyle) {
     StyleDifference diff;
     diff.setNeedsPaintInvalidationObject();
     SVGResourcesCache::clientStyleChanged(&parentInlineLayoutObject(), diff,
                                           selectionStyle);
   }
 
   SkPaint paint;
   if (setupTextPaint(paintInfo, selectionStyle, resourceMode, paint))
     paintText(paintInfo, textRun, fragment, startPosition, endPosition, paint);
 
   if (style != selectionStyle) {
     StyleDifference diff;
     diff.setNeedsPaintInvalidationObject();
     SVGResourcesCache::clientStyleChanged(&parentInlineLayoutObject(), diff,
                                           style);
   }
 
-  // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part
+  // Eventually draw text using regular style from the end position of the
+  // selection to the end of the current chunk part.
   if (endPosition < static_cast<int>(fragment.length) &&
       !paintSelectedTextOnly) {
     SkPaint paint;
     if (setupTextPaint(paintInfo, style, resourceMode, paint))
       paintText(paintInfo, textRun, fragment, endPosition, fragment.length,
                 paint);
   }
 }
 
 Vector<SVGTextFragmentWithRange> SVGInlineTextBoxPainter::collectTextMatches(
     DocumentMarker* marker) const {
   const Vector<SVGTextFragmentWithRange> emptyTextMatchList;
 
-  // SVG does not support grammar or spellcheck markers, so skip anything but TextMatch.
+  // SVG does not support grammar or spellcheck markers, so skip anything but
+  // TextMatch.
   if (marker->type() != DocumentMarker::TextMatch)
     return emptyTextMatchList;
 
   if (!inlineLayoutObject().frame()->editor().markedTextMatchesAreHighlighted())
     return emptyTextMatchList;
 
   int markerStartPosition =
       std::max<int>(marker->startOffset() - m_svgInlineTextBox.start(), 0);
   int markerEndPosition =
       std::min<int>(marker->endOffset() - m_svgInlineTextBox.start(),
@@ skipping 88 matching lines @@
     }
     FloatRect fragmentRect = m_svgInlineTextBox.selectionRectForTextFragment(
         fragment, textMatchInfo.startPosition, textMatchInfo.endPosition,
         style);
     paintInfo.context.setFillColor(color);
     paintInfo.context.fillRect(fragmentRect);
   }
 }
 
 }  // namespace blink