Remove unsafe getFontMetrics methods

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 167 matching lines @@
   TextPainter::Style textStyle = TextPainter::textPaintingStyle(
       m_inlineTextBox.getLineLayoutItem(), styleToUse, paintInfo);
   TextPainter::Style selectionStyle = TextPainter::selectionPaintingStyle(
       m_inlineTextBox.getLineLayoutItem(), haveSelection, paintInfo, textStyle);
   bool paintSelectedTextOnly = (paintInfo.phase == PaintPhaseSelection);
   bool paintSelectedTextSeparately =
       !paintSelectedTextOnly && textStyle != selectionStyle;
 
   // Set our font.
   const Font& font = styleToUse.font();
+  const SimpleFontData* fontData = font.primaryFont();
+  DCHECK(fontData);
 
-  LayoutPoint textOrigin(boxOrigin.x(),
-                         boxOrigin.y() + font.getFontMetrics().ascent());
+  int ascent = fontData ? fontData->getFontMetrics().ascent() : 0;
+  LayoutPoint textOrigin(boxOrigin.x(), boxOrigin.y() + ascent);
 
   // 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)) {
@@ skipping 344 matching lines @@
 
   // 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();
+
+  const SimpleFontData* fontData =
+      m_inlineTextBox.getLineLayoutItem()
+          .style(m_inlineTextBox.isFirstLineStyle())
+          ->font()
+          .primaryFont();
+  DCHECK(fontData);
+  int baseline = fontData ? fontData->getFontMetrics().ascent() : 0;
   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.
     underlineOffset = baseline + 2;
   }
@@ skipping 377 matching lines @@
                                          true);
   if (m_inlineTextBox.isFirstLineStyle())
     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();
+  const SimpleFontData* fontData = styleToUse.font().primaryFont();
+  DCHECK(fontData);
+  float baseline = fontData ? fontData->getFontMetrics().ascent() : 0;
 
   // 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.
-  float textDecorationThickness =
-      styleToUse.getFontMetrics().underlineThickness();
-  int fontHeightInt = (int)(styleToUse.getFontMetrics().floatHeight() + 0.5);
+  float textDecorationThickness = 0.0;
+  int fontHeightInt = 0;
+  if (fontData) {
+    textDecorationThickness = fontData->getFontMetrics().underlineThickness();
+    fontHeightInt = (int)(fontData->getFontMetrics().floatHeight() + 0.5);
+  }
   if ((textDecorationThickness == 0.f) ||
       (textDecorationThickness >= (fontHeightInt >> 1)))
     textDecorationThickness =
         std::max(1.f, styleToUse.computedFontSize() / 10.f);
 
   context.setStrokeThickness(textDecorationThickness);
 
   bool antialiasDecoration = shouldSetDecorationAntialias(
       overline.style, underline.style, linethrough.style);
 
   // Offset between lines - always non-zero, so lines never cross each other.
   float doubleOffset = textDecorationThickness + 1.f;
 
-  if (deco & TextDecorationUnderline) {
+  if ((deco & TextDecorationUnderline) && fontData) {
     const int underlineOffset = computeUnderlineOffset(
-        styleToUse.getTextUnderlinePosition(), styleToUse.getFontMetrics(),
+        styleToUse.getTextUnderlinePosition(), fontData->getFontMetrics(),
         &m_inlineTextBox, textDecorationThickness);
     paintAppliedDecoration(
         context, FloatPoint(localOrigin) + FloatPoint(0, underlineOffset),
         width.toFloat(), doubleOffset, 1, underline, textDecorationThickness,
         antialiasDecoration, isPrinting);
   }
   if (deco & TextDecorationOverline) {
     paintAppliedDecoration(context, FloatPoint(localOrigin), width.toFloat(),
                            -doubleOffset, 1, overline, textDecorationThickness,
                            antialiasDecoration, isPrinting);
@@ skipping 53 matching lines @@
   // |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.
   int lineThickness = 1;
-  int baseline = m_inlineTextBox.getLineLayoutItem()
-                     .style(m_inlineTextBox.isFirstLineStyle())
-                     ->getFontMetrics()
-                     .ascent();
+  const SimpleFontData* fontData =
+      m_inlineTextBox.getLineLayoutItem()
+          .style(m_inlineTextBox.isFirstLineStyle())
+          ->font()
+          .primaryFont();
+  DCHECK(fontData);
+  int baseline = fontData ? fontData->getFontMetrics().ascent() : 0;
   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.
   start += 1;
   width -= 2;
 
@@ skipping 21 matching lines @@
   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;
+
+  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() + font.getFontMetrics().ascent());
+                         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);
 }
 
 void InlineTextBoxPainter::paintTextMatchMarkerBackground(
     const PaintInfo& paintInfo,
     const LayoutPoint& boxOrigin,
     DocumentMarker* marker,
@@ skipping 17 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