Extract helper function.

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"
 #include "core/layout/LayoutTextCombine.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/api/LineLayoutBox.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/TextPainter.h"
 #include "core/style/AppliedTextDecoration.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
+namespace {
+
+std::pair<unsigned, unsigned> GetMarkerPaintOffsets(
+    const DocumentMarker& marker,
+    const InlineTextBox& textBox) {
+  const unsigned startOffset = marker.startOffset() > textBox.start()

[chrishtr, 2016/12/23 20:57:19]

Why not just use std::max like the code used to?

[Andrey Kraynov, 2016/12/23 22:27:47]

But then it will look like |std::max(someUnsignedIntValue, 0U)|.
Which is strange, because |someUnsignedIntValue| will be always greater than 0.

[Andrey Kraynov, 2016/12/23 22:31:00]

Greater then or equal to 0, of course.

+                                   ? marker.startOffset() - textBox.start()
+                                   : 0U;
+  const unsigned endOffset =
+      std::min(marker.endOffset() - textBox.start(), textBox.len());
+  return std::make_pair(startOffset, endOffset);
+}
+}
+
 static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition,
                                   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.
@@ skipping 694 matching lines @@
 
   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.
   for (; markerIt != markers.end(); ++markerIt) {
-    DocumentMarker* marker = *markerIt;
+    DCHECK(*markerIt);
+    const DocumentMarker& marker = **markerIt;
 
     // Paint either the background markers or the foreground markers, but not
     // both.
-    switch (marker->type()) {
+    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()) {
+    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.
       continue;
     }
-    if (marker->startOffset() > m_inlineTextBox.end()) {
+    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()) {
+    switch (marker.type()) {
       case DocumentMarker::Spelling:
         m_inlineTextBox.paintDocumentMarker(paintInfo.context, boxOrigin,
                                             marker, style, font, false);
         break;
       case DocumentMarker::Grammar:
         m_inlineTextBox.paintDocumentMarker(paintInfo.context, boxOrigin,
                                             marker, style, font, true);
         break;
       case DocumentMarker::TextMatch:
         if (markerPaintPhase == DocumentMarkerPaintPhase::Background)
           m_inlineTextBox.paintTextMatchMarkerBackground(paintInfo, boxOrigin,
                                                          marker, style, font);
         else
           m_inlineTextBox.paintTextMatchMarkerForeground(paintInfo, boxOrigin,
                                                          marker, style, font);
         break;
       case DocumentMarker::Composition: {
-        CompositionUnderline underline(
-            marker->startOffset(), marker->endOffset(),
-            marker->underlineColor(), marker->thick(),
-            marker->backgroundColor());
+        CompositionUnderline underline(marker.startOffset(), marker.endOffset(),
+                                       marker.underlineColor(), marker.thick(),
+                                       marker.backgroundColor());
         if (markerPaintPhase == DocumentMarkerPaintPhase::Background)
           paintSingleCompositionBackgroundRun(
               paintInfo.context, boxOrigin, style, font,
               underline.backgroundColor(), underlinePaintStart(underline),
               underlinePaintEnd(underline));
         else
           paintCompositionUnderline(paintInfo.context, boxOrigin, underline);
       } break;
       default:
         ASSERT_NOT_REACHED();
     }
   }
 }
 
 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(
     DocumentMarker::MarkerType markerType) {
   switch (markerType) {
     case DocumentMarker::Spelling:
       return GraphicsContext::DocumentMarkerSpellingLineStyle;
     case DocumentMarker::Grammar:
       return GraphicsContext::DocumentMarkerGrammarLineStyle;
     default:
       ASSERT_NOT_REACHED();
       return GraphicsContext::DocumentMarkerSpellingLineStyle;
   }
 }
 
 void InlineTextBoxPainter::paintDocumentMarker(GraphicsContext& context,
                                                const LayoutPoint& boxOrigin,
-                                               DocumentMarker* marker,
+                                               const DocumentMarker& marker,
                                                const ComputedStyle& style,
                                                const Font& font,
                                                bool grammar) {
   // Never print spelling/grammar markers (5327887)
   if (m_inlineTextBox.getLineLayoutItem().document().printing())
     return;
 
   if (m_inlineTextBox.truncation() == cFullTruncation)
     return;
 
   LayoutUnit start;  // start of line to draw, relative to tx
   LayoutUnit width = m_inlineTextBox.logicalWidth();  // how much line to draw
 
   // Determine whether we need to measure text
   bool markerSpansWholeBox = true;
-  if (m_inlineTextBox.start() <= marker->startOffset())
+  if (m_inlineTextBox.start() <= marker.startOffset())
     markerSpansWholeBox = false;
   if ((m_inlineTextBox.end() + 1) !=
-      marker->endOffset())  // end points at the last char, not past it
+      marker.endOffset())  // end points at the last char, not past it
     markerSpansWholeBox = false;
   if (m_inlineTextBox.truncation() != cNoTruncation)
     markerSpansWholeBox = false;
 
   if (!markerSpansWholeBox || grammar) {
-    int startPosition =
-        std::max<int>(marker->startOffset() - m_inlineTextBox.start(), 0);
-    int endPosition = std::min<int>(
-        marker->endOffset() - static_cast<int>(m_inlineTextBox.start()),
-        m_inlineTextBox.len());
+    int startPosition, endPosition;
+    std::tie(startPosition, endPosition) =
+        GetMarkerPaintOffsets(marker, m_inlineTextBox);
 
     if (m_inlineTextBox.truncation() != cNoTruncation)
       endPosition = std::min<int>(endPosition, m_inlineTextBox.truncation());
 
     // Calculate start & width
     int deltaY = (m_inlineTextBox.getLineLayoutItem()
                           .style()
                           ->isFlippedLinesWritingMode()
                       ? m_inlineTextBox.root().selectionBottom() -
                             m_inlineTextBox.logicalBottom()
@@ skipping 34 matching lines @@
     // 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.
     underlineOffset = baseline + 2;
   }
   context.drawLineForDocumentMarker(
       FloatPoint((boxOrigin.x() + start).toFloat(),
                  (boxOrigin.y() + underlineOffset).toFloat()),
-      width.toFloat(), lineStyleForMarkerType(marker->type()));
+      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.
@@ skipping 285 matching lines @@
       FloatPoint(
           boxOrigin.x() + start,
           (boxOrigin.y() + m_inlineTextBox.logicalHeight() - lineThickness)
               .toFloat()),
       width);
 }
 
 void InlineTextBoxPainter::paintTextMatchMarkerForeground(
     const PaintInfo& paintInfo,
     const LayoutPoint& boxOrigin,
-    DocumentMarker* marker,
+    const 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.
-  int sPos =
-      std::max(marker->startOffset() - m_inlineTextBox.start(), (unsigned)0);

[Andrey Kraynov, 2016/12/21 17:43:18]

This is obviously pointless call to std::max() function, because type of the
|marker->startOffset() - m_inlineTextBox.start()| expression is |unsigned| and
it will always greater that 0.
Compiler can even give a warning for the following code:
|std::max(someUnsignedValue, 0U);|
taking the max of a value and unsigned zero is always equal to the other value
[-Werror,-Wmax-unsigned-zero]

Also, TextPainter::paint() function takes offsets as |unsigned|.

-  int ePos = std::min(marker->endOffset() - m_inlineTextBox.start(),
-                      m_inlineTextBox.len());
+  const auto paintOffsets = GetMarkerPaintOffsets(marker, m_inlineTextBox);
   TextRun run = m_inlineTextBox.constructTextRun(style);
 
   Color textColor =
-      LayoutTheme::theme().platformTextSearchColor(marker->activeMatch());
+      LayoutTheme::theme().platformTextSearchColor(marker.activeMatch());
   if (style.visitedDependentColor(CSSPropertyColor) == textColor)
     return;
 
   const SimpleFontData* fontData = font.primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return;
 
   TextPainter::Style textStyle;
   textStyle.currentColor = textStyle.fillColor = textStyle.strokeColor =
       textStyle.emphasisMarkColor = textColor;
   textStyle.strokeWidth = style.textStrokeWidth();
   textStyle.shadow = 0;
 
   LayoutRect boxRect(boxOrigin, LayoutSize(m_inlineTextBox.logicalWidth(),
                                            m_inlineTextBox.logicalHeight()));
   LayoutPoint textOrigin(boxOrigin.x(),
                          boxOrigin.y() + fontData->getFontMetrics().ascent());
   TextPainter textPainter(paintInfo.context, font, run, textOrigin, boxRect,
                           m_inlineTextBox.isHorizontal());
 
-  textPainter.paint(sPos, ePos, m_inlineTextBox.len(), textStyle, 0);
+  textPainter.paint(paintOffsets.first, paintOffsets.second,
+                    m_inlineTextBox.len(), textStyle, 0);
 }
 
 void InlineTextBoxPainter::paintTextMatchMarkerBackground(
     const PaintInfo& paintInfo,
     const LayoutPoint& boxOrigin,
-    DocumentMarker* marker,
+    const DocumentMarker& marker,
     const ComputedStyle& style,
     const Font& font) {
   if (!LineLayoutAPIShim::layoutObjectFrom(m_inlineTextBox.getLineLayoutItem())
            ->frame()
            ->editor()
            .markedTextMatchesAreHighlighted())
     return;
 
-  int sPos =
-      std::max(marker->startOffset() - m_inlineTextBox.start(), (unsigned)0);
-  int ePos = std::min(marker->endOffset() - m_inlineTextBox.start(),
-                      m_inlineTextBox.len());
+  const auto paintOffsets = GetMarkerPaintOffsets(marker, m_inlineTextBox);
   TextRun run = m_inlineTextBox.constructTextRun(style);
 
   Color color = LayoutTheme::theme().platformTextSearchHighlightColor(
-      marker->activeMatch());
+      marker.activeMatch());
   GraphicsContext& context = paintInfo.context;
   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);
+                               boxRect.height().toInt(), color,
+                               paintOffsets.first, paintOffsets.second);
 }
 
 }  // namespace blink