blink: Fix cc/paint skia type mismatches

third_party/WebKit/Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. 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 274 matching lines @@
     // For vertical upright text we need to compensate the inherited 90deg CW
     // rotation (using a 90deg CCW rotation).
     return (font->platformData().isVerticalAnyUpright() && font->verticalData())
                ? CCWRotation
                : NoRotation;
   }
 
   void appendRun(unsigned start,
                  unsigned count,
                  const SimpleFontData* fontData) {
-    PaintFlags flags;
-    fontData->platformData().setupPaint(&flags, m_deviceScaleFactor, m_font);
-    flags.setTextEncoding(PaintFlags::kGlyphID_TextEncoding);
+    SkPaint paint;
+    fontData->platformData().setupPaint(&paint, m_deviceScaleFactor, m_font);
+    paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
     const SkTextBlobBuilder::RunBuffer& buffer =
-        m_hasVerticalOffsets ? m_builder.allocRunPos(flags, count)
-                             : m_builder.allocRunPosH(flags, count, 0);
+        m_hasVerticalOffsets ? m_builder.allocRunPos(paint, count)
+                             : m_builder.allocRunPosH(paint, count, 0);
 
     const uint16_t* glyphs = m_buffer.glyphs(start);
     const float* offsets = m_buffer.offsets(start);
     std::copy(glyphs, glyphs + count, buffer.glyphs);
 
     if (m_rotation == NoRotation) {
       std::copy(offsets, offsets + (m_hasVerticalOffsets ? 2 * count : count),
                 buffer.pos);
     } else {
       ASSERT(m_hasVerticalOffsets);
@@ skipping 43 matching lines @@
       m.setSinCos(-1, 0, point.x(), point.y());
       canvas->concat(m);
     }
 
     canvas->drawTextBlob(blob.first, point.x(), point.y(), flags);
   }
 }
 
 static int getInterceptsFromBloberizer(const GlyphBuffer& glyphBuffer,
                                        const Font* font,
-                                       const PaintFlags& flags,
+                                       const SkPaint& paint,
                                        float deviceScaleFactor,
                                        const std::tuple<float, float>& bounds,
                                        SkScalar* interceptsBuffer) {
   SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
   GlyphBufferBloberizer bloberizer(glyphBuffer, font, deviceScaleFactor);
 
   int numIntervals = 0;
   while (!bloberizer.done()) {
     auto blob = bloberizer.next();
     DCHECK(blob.first);
 
     // GlyphBufferBloberizer splits for a new blob rotation, but does not split
     // for a change in font. A TextBlob can contain runs with differing fonts
     // and the getTextBlobIntercepts method handles multiple fonts for us. For
     // upright in vertical blobs we currently have to bail, see crbug.com/655154
     if (blob.second == BlobRotation::CCWRotation)
       continue;
 
     SkScalar* offsetInterceptsBuffer = nullptr;
     if (interceptsBuffer)
       offsetInterceptsBuffer = &interceptsBuffer[numIntervals];
-    numIntervals += flags.getTextBlobIntercepts(blob.first.get(), boundsArray,
+    numIntervals += paint.getTextBlobIntercepts(blob.first.get(), boundsArray,
                                                 offsetInterceptsBuffer);
   }
   return numIntervals;
 }
 
 void Font::getTextIntercepts(const TextRunPaintInfo& runInfo,
                              float deviceScaleFactor,
                              const PaintFlags& flags,
                              const std::tuple<float, float>& bounds,
                              Vector<TextIntercept>& intercepts) const {
   if (shouldSkipDrawing())
     return;
 
   GlyphBuffer glyphBuffer(GlyphBuffer::Type::TextIntercepts);
   buildGlyphBuffer(runInfo, glyphBuffer);
 
   // Get the number of intervals, without copying the actual values by
   // specifying nullptr for the buffer, following the Skia allocation model for
   // retrieving text intercepts.
+  SkPaint paint(ToSkPaint(flags));

[enne (OOO), 2017/02/27 05:16:59]

This is changing back because I think the text intercept code should continue to
live in skia.  Maybe this can get better by only needing the particular SkPaint
bits that change intercepts, but I think this is the right place to cut this
abstraction.

   int numIntervals = getInterceptsFromBloberizer(
-      glyphBuffer, this, flags, deviceScaleFactor, bounds, nullptr);
+      glyphBuffer, this, paint, deviceScaleFactor, bounds, nullptr);
   if (!numIntervals)
     return;
   DCHECK_EQ(numIntervals % 2, 0);
   intercepts.resize(numIntervals / 2);
 
-  getInterceptsFromBloberizer(glyphBuffer, this, flags, deviceScaleFactor,
+  getInterceptsFromBloberizer(glyphBuffer, this, paint, deviceScaleFactor,
                               bounds,
                               reinterpret_cast<SkScalar*>(intercepts.data()));
 }
 
 static inline FloatRect pixelSnappedSelectionRect(FloatRect rect) {
   // Using roundf() rather than ceilf() for the right edge as a compromise to
   // ensure correct caret positioning.
   float roundedX = roundf(rect.x());
   return FloatRect(roundedX, rect.y(), roundf(rect.maxX() - roundedX),
                    rect.height());
@@ skipping 155 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink