reflow comments in core/paint

third_party/WebKit/Source/core/paint/InlineTextBoxPainter.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/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 78 matching lines @@
   bool isPrinting = paintInfo.isPrinting();
 
   // Determine whether or not we're selected.
   bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip &&
                        m_inlineTextBox.getSelectionState() != SelectionNone;
   if (!haveSelection && paintInfo.phase == PaintPhaseSelection) {
     // When only painting the selection, don't bother to paint if there is none.
     return;
   }
 
-  // The text clip phase already has a LayoutObjectDrawingRecorder. Text clips are initiated only in BoxPainter::paintFillLayer,
-  // which is already within a LayoutObjectDrawingRecorder.
+  // The text clip phase already has a LayoutObjectDrawingRecorder. Text clips
+  // are initiated only in BoxPainter::paintFillLayer, which is already within a
+  // LayoutObjectDrawingRecorder.
   Optional<DrawingRecorder> drawingRecorder;
   if (paintInfo.phase != PaintPhaseTextClip) {
     if (DrawingRecorder::useCachedDrawingIfPossible(
             paintInfo.context, m_inlineTextBox,
             DisplayItem::paintPhaseToDrawingType(paintInfo.phase)))
       return;
     LayoutRect paintRect(logicalVisualOverflow);
     m_inlineTextBox.logicalRectToPhysicalRect(paintRect);
     if (paintInfo.phase != PaintPhaseSelection &&
         (haveSelection || paintsMarkerHighlights(inlineLayoutObject())))
@@ skipping 70 matching lines @@
   bool paintSelectedTextOnly = (paintInfo.phase == PaintPhaseSelection);
   bool paintSelectedTextSeparately =
       !paintSelectedTextOnly && textStyle != selectionStyle;
 
   // Set our font.
   const Font& font = styleToUse.font();
 
   LayoutPoint textOrigin(boxOrigin.x(),
                          boxOrigin.y() + font.getFontMetrics().ascent());
 
-  // 1. Paint backgrounds behind text if needed. Examples of such backgrounds include selection
-  // and composition highlights.
+  // 1. Paint backgrounds behind text if needed. Examples of such backgrounds
+  // include selection and composition highlights.
   if (paintInfo.phase != PaintPhaseSelection &&
       paintInfo.phase != PaintPhaseTextClip && !isPrinting) {
     paintDocumentMarkers(paintInfo, boxOrigin, styleToUse, font,
                          DocumentMarkerPaintPhase::Background);
 
     const LayoutObject& textBoxLayoutObject = inlineLayoutObject();
     if (haveSelection && !paintsCompositionMarkers(textBoxLayoutObject)) {
       if (combinedText)
         paintSelection<InlineTextBoxPainter::PaintOptions::CombinedText>(
             context, boxRect, styleToUse, font, selectionStyle.fillColor,
             combinedText);
       else
         paintSelection<InlineTextBoxPainter::PaintOptions::Normal>(
             context, boxRect, styleToUse, font, selectionStyle.fillColor);
     }
   }
 
-  // 2. Now paint the foreground, including text and decorations like underline/overline (in quirks mode only).
+  // 2. Now paint the foreground, including text and decorations like
+  // underline/overline (in quirks mode only).
   int selectionStart = 0;
   int selectionEnd = 0;
   if (paintSelectedTextOnly || paintSelectedTextSeparately)
     m_inlineTextBox.selectionStartEnd(selectionStart, selectionEnd);
 
   bool respectHyphen =
       selectionEnd == static_cast<int>(m_inlineTextBox.len()) &&
       m_inlineTextBox.hasHyphen();
   if (respectHyphen)
     selectionEnd = textRun.length();
@@ skipping 16 matching lines @@
   if (combinedText)
     textPainter.setCombinedText(combinedText);
 
   if (!paintSelectedTextOnly) {
     int startOffset = 0;
     int endOffset = length;
     if (paintSelectedTextSeparately && selectionStart < selectionEnd) {
       startOffset = selectionEnd;
       endOffset = selectionStart;
     }
-    // Where the text and its flow have opposite directions then our offset into the text given by |truncation| is at
-    // the start of the part that will be visible.
+    // Where the text and its flow have opposite directions then our offset into
+    // the text given by |truncation| is at the start of the part that will be
+    // visible.
     if (m_inlineTextBox.truncation() != cNoTruncation &&
         m_inlineTextBox.getLineLayoutItem()
                 .containingBlock()
                 .style()
                 ->isLeftToRightDirection() !=
             m_inlineTextBox.isLeftToRightDirection()) {
       startOffset = m_inlineTextBox.truncation();
       endOffset = textRun.length();
     }
 
@@ skipping 136 matching lines @@
     return;
 
   DCHECK(m_inlineTextBox.truncation() != cFullTruncation);
   DCHECK(m_inlineTextBox.len());
 
   DocumentMarkerVector markers =
       m_inlineTextBox.getLineLayoutItem().document().markers().markersFor(
           m_inlineTextBox.getLineLayoutItem().node());
   DocumentMarkerVector::const_iterator markerIt = markers.begin();
 
-  // Give any document markers that touch this run a chance to draw before the text has been drawn.
-  // Note end() points at the last char, not one past it like endOffset and ranges do.
+  // Give any document markers that touch this run a chance to draw before the
+  // text has been drawn.  Note end() points at the last char, not one past it
+  // like endOffset and ranges do.
   for (; markerIt != markers.end(); ++markerIt) {
     DocumentMarker* marker = *markerIt;
 
-    // Paint either the background markers or the foreground markers, but not both
+    // Paint either the background markers or the foreground markers, but not
+    // both.
     switch (marker->type()) {
       case DocumentMarker::Grammar:
       case DocumentMarker::Spelling:
         if (markerPaintPhase == DocumentMarkerPaintPhase::Background)
           continue;
         break;
       case DocumentMarker::TextMatch:
       case DocumentMarker::Composition:
         break;
       default:
         continue;
     }
 
     if (marker->endOffset() <= m_inlineTextBox.start()) {
-      // marker is completely before this run.  This might be a marker that sits before the
-      // first run we draw, or markers that were within runs we skipped due to truncation.
+      // marker is completely before this run.  This might be a marker that sits
+      // before the first run we draw, or markers that were within runs we
+      // skipped due to truncation.
       continue;
     }
     if (marker->startOffset() > m_inlineTextBox.end()) {
       // marker is completely after this run, bail.  A later run will paint it.
       break;
     }
 
     // marker intersects this run.  Paint it.
     switch (marker->type()) {
       case DocumentMarker::Spelling:
@@ skipping 93 matching lines @@
     LayoutPoint startPoint(boxOrigin.x(), boxOrigin.y() - deltaY);
     TextRun run = m_inlineTextBox.constructTextRun(style);
 
     // FIXME: Convert the document markers to float rects.
     IntRect markerRect = enclosingIntRect(font.selectionRectForText(
         run, FloatPoint(startPoint), selHeight, startPosition, endPosition));
     start = markerRect.x() - startPoint.x();
     width = LayoutUnit(markerRect.width());
   }
 
-  // IMPORTANT: The misspelling underline is not considered when calculating the text bounds, so we have to
-  // make sure to fit within those bounds.  This means the top pixel(s) of the underline will overlap the
-  // bottom pixel(s) of the glyphs in smaller font sizes.  The alternatives are to increase the line spacing (bad!!)
-  // or decrease the underline thickness.  The overlap is actually the most useful, and matches what AppKit does.
-  // So, we generally place the underline at the bottom of the text, but in larger fonts that's not so good so
-  // we pin to two pixels under the baseline.
+  // IMPORTANT: The misspelling underline is not considered when calculating the
+  // text bounds, so we have to make sure to fit within those bounds.  This
+  // means the top pixel(s) of the underline will overlap the bottom pixel(s) of
+  // the glyphs in smaller font sizes.  The alternatives are to increase the
+  // line spacing (bad!!) or decrease the underline thickness.  The overlap is
+  // actually the most useful, and matches what AppKit does.  So, we generally
+  // place the underline at the bottom of the text, but in larger fonts that's
+  // not so good so we pin to two pixels under the baseline.
   int lineThickness = misspellingLineThickness;
   int baseline = m_inlineTextBox.getLineLayoutItem()
                      .style(m_inlineTextBox.isFirstLineStyle())
                      ->getFontMetrics()
                      .ascent();
   int descent = (m_inlineTextBox.logicalHeight() - baseline).toInt();
   int underlineOffset;
   if (descent <= (lineThickness + 2)) {
     // Place the underline at the very bottom of the text in small/medium fonts.
     underlineOffset = (m_inlineTextBox.logicalHeight() - lineThickness).toInt();
   } else {
-    // In larger fonts, though, place the underline up near the baseline to prevent a big gap.
+    // In larger fonts, though, place the underline up near the baseline to
+    // prevent a big gap.
     underlineOffset = baseline + 2;
   }
   context.drawLineForDocumentMarker(
       FloatPoint((boxOrigin.x() + start).toFloat(),
                  (boxOrigin.y() + underlineOffset).toFloat()),
       width.toFloat(), lineStyleForMarkerType(marker->type()));
 }
 
 template <InlineTextBoxPainter::PaintOptions options>
 void InlineTextBoxPainter::paintSelection(GraphicsContext& context,
                                           const LayoutRect& boxRect,
                                           const ComputedStyle& style,
                                           const Font& font,
                                           Color textColor,
                                           LayoutTextCombine* combinedText) {
   // See if we have a selection to paint at all.
   int sPos, ePos;
   m_inlineTextBox.selectionStartEnd(sPos, ePos);
   if (sPos >= ePos)
     return;
 
   Color c = m_inlineTextBox.getLineLayoutItem().selectionBackgroundColor();
   if (!c.alpha())
     return;
 
-  // If the text color ends up being the same as the selection background, invert the selection
-  // background.
+  // If the text color ends up being the same as the selection background,
+  // invert the selection background.
   if (textColor == c)
     c = Color(0xff - c.red(), 0xff - c.green(), 0xff - c.blue());
 
   // If the text is truncated, let the thing being painted in the truncation
   // draw its own highlight.
   unsigned start = m_inlineTextBox.start();
   int length = m_inlineTextBox.len();
   bool ltr = m_inlineTextBox.isLeftToRightDirection();
   bool flowIsLTR =
       m_inlineTextBox.getLineLayoutItem().style()->isLeftToRightDirection();
@@ skipping 13 matching lines @@
       style, string, m_inlineTextBox.getLineLayoutItem().textLength() -
                          m_inlineTextBox.start(),
       respectHyphen ? &charactersWithHyphen : 0);
   if (respectHyphen)
     ePos = textRun.length();
 
   GraphicsContextStateSaver stateSaver(context);
 
   if (options == InlineTextBoxPainter::PaintOptions::CombinedText) {
     ASSERT(combinedText);
-    // We can't use the height of m_inlineTextBox because LayoutTextCombine's inlineTextBox is horizontal within vertical flow
+    // We can't use the height of m_inlineTextBox because LayoutTextCombine's
+    // inlineTextBox is horizontal within vertical flow
     combinedText->transformToInlineCoordinates(context, boxRect, true);
     context.drawHighlightForText(font, textRun, FloatPoint(boxRect.location()),
                                  boxRect.height().toInt(), c, sPos, ePos);
     return;
   }
 
   LayoutUnit selectionBottom = m_inlineTextBox.root().selectionBottom();
   LayoutUnit selectionTop = m_inlineTextBox.root().selectionTop();
 
   int deltaY = roundToInt(
       m_inlineTextBox.getLineLayoutItem().style()->isFlippedLinesWritingMode()
           ? selectionBottom - m_inlineTextBox.logicalBottom()
           : m_inlineTextBox.logicalTop() - selectionTop);
   int selHeight = std::max(0, roundToInt(selectionBottom - selectionTop));
 
   FloatPoint localOrigin(boxRect.x().toFloat(),
                          (boxRect.y() - deltaY).toFloat());
   LayoutRect selectionRect = LayoutRect(
       font.selectionRectForText(textRun, localOrigin, selHeight, sPos, ePos));
   if (m_inlineTextBox.hasWrappedSelectionNewline()
-      // For line breaks, just painting a selection where the line break itself is rendered is sufficient.
+      // For line breaks, just painting a selection where the line break itself
+      // is rendered is sufficient.
       && !m_inlineTextBox.isLineBreak())
     expandToIncludeNewlineForSelection(selectionRect);
 
   // Line breaks report themselves as having zero width for layout purposes,
   // and so will end up positioned at (0, 0), even though we paint their
   // selection highlight with character width. For RTL then, we have to
   // explicitly shift the selection rect over to paint in the right location.
   if (!m_inlineTextBox.isLeftToRightDirection() &&
       m_inlineTextBox.isLineBreak())
     selectionRect.move(-selectionRect.width(), LayoutUnit());
@@ skipping 19 matching lines @@
                                   const FontMetrics& fontMetrics,
                                   const InlineTextBox* inlineTextBox,
                                   const float textDecorationThickness) {
   // Compute the gap between the font and the underline. Use at least one
   // pixel gap, if underline is thick then use a bigger gap.
   int gap = 0;
 
   // Underline position of zero means draw underline on Baseline Position,
   // in Blink we need at least 1-pixel gap to adding following check.
   // Positive underline Position means underline should be drawn above baselin e
-  // and negative value means drawing below baseline, negating the value as in Blink
-  // downward Y-increases.
+  // and negative value means drawing below baseline, negating the value as in
+  // Blink downward Y-increases.
 
   if (fontMetrics.underlinePosition())
     gap = -fontMetrics.underlinePosition();
   else
     gap = std::max<int>(1, ceilf(textDecorationThickness / 2.f));
 
   // FIXME: We support only horizontal text for now.
   switch (underlinePosition) {
     case TextUnderlinePositionAuto:
       return fontMetrics.ascent() +
              gap;  // Position underline near the alphabetic baseline.
     case TextUnderlinePositionUnder: {
-      // Position underline relative to the under edge of the lowest element's content box.
+      // Position underline relative to the under edge of the lowest element's
+      // content box.
       const LayoutUnit offset =
           inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
       if (offset > 0)
         return (inlineTextBox->logicalHeight() + gap + offset).toInt();
       return (inlineTextBox->logicalHeight() + gap).toInt();
     }
   }
 
   ASSERT_NOT_REACHED();
   return fontMetrics.ascent() + gap;
@@ skipping 49 matching lines @@
   // Each Bezier curve starts at the same pixel that the previous one
   // ended. We need to subtract (stepCount - 1) pixels when calculating the
   // length covered to account for that.
   float uncoveredLength = length - (stepCount * step - (stepCount - 1));
   float adjustment = uncoveredLength / stepCount;
   step += adjustment;
   controlPointDistance += adjustment;
 }
 
 /*
- * Draw one cubic Bezier curve and repeat the same pattern long the the decoration's axis.
- * The start point (p1), controlPoint1, controlPoint2 and end point (p2) of the Bezier curve
- * form a diamond shape:
+ * Draw one cubic Bezier curve and repeat the same pattern long the the
+ * decoration's axis.  The start point (p1), controlPoint1, controlPoint2 and
+ * end point (p2) of the Bezier curve form a diamond shape:
  *
  *                              step
  *                         |-----------|
  *
  *                   controlPoint1
  *                         +
  *
  *
  *                  . .
  *                .     .
@@ skipping 14 matching lines @@
                                      FloatPoint p1,
                                      FloatPoint p2,
                                      float strokeThickness) {
   context.adjustLineToPixelBoundaries(p1, p2, strokeThickness,
                                       context.getStrokeStyle());
 
   Path path;
   path.moveTo(p1);
 
   // Distance between decoration's axis and Bezier curve's control points.
-  // The height of the curve is based on this distance. Use a minimum of 6 pixels distance since
-  // the actual curve passes approximately at half of that distance, that is 3 pixels.
-  // The minimum height of the curve is also approximately 3 pixels. Increases the curve's height
+  // The height of the curve is based on this distance. Use a minimum of 6
+  // pixels distance since the actual curve passes approximately at half of that
+  // distance, that is 3 pixels.  The minimum height of the curve is also
+  // approximately 3 pixels. Increases the curve's height
   // as strockThickness increases to make the curve looks better.
   float controlPointDistance = 3 * std::max<float>(2, strokeThickness);
 
   // Increment used to form the diamond shape between start point (p1), control
   // points and end point (p2) along the axis of the decoration. Makes the
   // curve wider as strockThickness increases to make the curve looks better.
   float step = 2 * std::max<float>(2, strokeThickness);
 
   bool isVerticalLine = (p1.x() == p2.x());
 
@@ skipping 122 matching lines @@
     textBoxLayoutObject.getTextDecorations(deco, underline, overline,
                                            linethrough, true, true);
 
   // Use a special function for underlines to get the positioning exactly right.
   bool isPrinting = paintInfo.isPrinting();
 
   const ComputedStyle& styleToUse =
       textBoxLayoutObject.styleRef(m_inlineTextBox.isFirstLineStyle());
   float baseline = styleToUse.getFontMetrics().ascent();
 
-  // Set the thick of the line to be 10% (or something else ?)of the computed font size and not less than 1px.
-  // Using computedFontSize should take care of zoom as well.
+  // Set the thick of the line to be 10% (or something else ?)of the computed
+  // font size and not less than 1px.  Using computedFontSize should take care
+  // of zoom as well.
 
-  // Update Underline thickness, in case we have Faulty Font Metrics calculating underline thickness by old method.
+  // Update Underline thickness, in case we have Faulty Font Metrics calculating
+  // underline thickness by old method.
   float textDecorationThickness =
       styleToUse.getFontMetrics().underlineThickness();
   int fontHeightInt = (int)(styleToUse.getFontMetrics().floatHeight() + 0.5);
   if ((textDecorationThickness == 0.f) ||
       (textDecorationThickness >= (fontHeightInt >> 1)))
     textDecorationThickness =
         std::max(1.f, styleToUse.computedFontSize() / 10.f);
 
   context.setStrokeThickness(textDecorationThickness);
 
@@ skipping 60 matching lines @@
   } else {
     unsigned paintFrom = ltr == flowIsLTR ? paintStart : paintEnd;
     unsigned paintLength =
         ltr == flowIsLTR
             ? paintEnd - paintStart
             : m_inlineTextBox.start() + m_inlineTextBox.len() - paintEnd;
     width = m_inlineTextBox.getLineLayoutItem().width(
         paintFrom, paintLength, LayoutUnit(m_inlineTextBox.textPos() + start),
         flowIsLTR ? LTR : RTL, m_inlineTextBox.isFirstLineStyle());
   }
-  // In RTL mode, start and width are computed from the right end of the text box:
-  // starting at |logicalWidth| - |start| and continuing left by |width| to
-  // |logicalWidth| - |start| - |width|. We will draw that line, but
-  // backwards: |logicalWidth| - |start| - |width| to |logicalWidth| - |start|.
+  // In RTL mode, start and width are computed from the right end of the text
+  // box: starting at |logicalWidth| - |start| and continuing left by |width| to
+  // |logicalWidth| - |start| - |width|. We will draw that line, but backwards:
+  // |logicalWidth| - |start| - |width| to |logicalWidth| - |start|.
   if (!flowIsLTR)
     start = m_inlineTextBox.logicalWidth().toFloat() - width - start;
 
-  // Thick marked text underlines are 2px thick as long as there is room for the 2px line under the baseline.
-  // All other marked text underlines are 1px thick.
-  // If there's not enough space the underline will touch or overlap characters.
+  // Thick marked text underlines are 2px thick as long as there is room for the
+  // 2px line under the baseline.  All other marked text underlines are 1px
+  // thick.  If there's not enough space the underline will touch or overlap
+  // characters.
   int lineThickness = 1;
   int baseline = m_inlineTextBox.getLineLayoutItem()
                      .style(m_inlineTextBox.isFirstLineStyle())
                      ->getFontMetrics()
                      .ascent();
   if (underline.thick() && m_inlineTextBox.logicalHeight() - baseline >= 2)
     lineThickness = 2;
 
-  // We need to have some space between underlines of subsequent clauses, because some input methods do not use different underline styles for those.
-  // We make each line shorter, which has a harmless side effect of shortening the first and last clauses, too.
+  // We need to have some space between underlines of subsequent clauses,
+  // because some input methods do not use different underline styles for those.
+  // We make each line shorter, which has a harmless side effect of shortening
+  // the first and last clauses, too.
   start += 1;
   width -= 2;
 
   context.setStrokeColor(underline.color());
   context.setStrokeThickness(lineThickness);
   context.drawLineForText(
       FloatPoint(
           boxOrigin.x() + start,
           (boxOrigin.y() + m_inlineTextBox.logicalHeight() - lineThickness)
               .toFloat()),
       width, m_inlineTextBox.getLineLayoutItem().document().printing());
 }
 
 void InlineTextBoxPainter::paintTextMatchMarkerForeground(
     const PaintInfo& paintInfo,
     const LayoutPoint& boxOrigin,
     DocumentMarker* marker,
     const ComputedStyle& style,
     const Font& font) {
   if (!inlineLayoutObject().frame()->editor().markedTextMatchesAreHighlighted())
     return;
 
-  // TODO(ramya.v): Extract this into a helper function and share many copies of this code.
+  // TODO(ramya.v): Extract this into a helper function and share many copies of
+  // this code.
   int sPos =
       std::max(marker->startOffset() - m_inlineTextBox.start(), (unsigned)0);
   int ePos = std::min(marker->endOffset() - m_inlineTextBox.start(),
                       m_inlineTextBox.len());
   TextRun run = m_inlineTextBox.constructTextRun(style);
 
   Color textColor =
       LayoutTheme::theme().platformTextSearchColor(marker->activeMatch());
   if (style.visitedDependentColor(CSSPropertyColor) == textColor)
     return;
@@ skipping 37 matching lines @@
   GraphicsContextStateSaver stateSaver(context);
 
   LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(),
                                            m_inlineTextBox.logicalHeight()));
   context.clip(FloatRect(boxRect));
   context.drawHighlightForText(font, run, FloatPoint(boxOrigin),
                                boxRect.height().toInt(), color, sPos, ePos);
 }
 
 }  // namespace blink