Rename paint data structures

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 17 matching lines @@
 #include "platform/LayoutUnit.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/CharacterRange.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontFallbackIterator.h"
 #include "platform/fonts/FontFallbackList.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/CachingWordShaper.h"
 #include "platform/geometry/FloatRect.h"
+#include "platform/graphics/paint/PaintCanvas.h"
+#include "platform/graphics/paint/PaintFlags.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/Character.h"
 #include "platform/text/TextRun.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/transforms/AffineTransform.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
@@ skipping 59 matching lines @@
     width = shaper.fillGlyphBufferForTextEmphasis(this, runInfo.run,
                                                   emphasisData, &glyphBuffer,
                                                   runInfo.from, runInfo.to);
   } else {
     width = shaper.fillGlyphBuffer(this, runInfo.run, nullptr, &glyphBuffer,
                                    runInfo.from, runInfo.to);
   }
   return width;
 }
 
-bool Font::drawText(SkCanvas* canvas,
+bool Font::drawText(PaintCanvas* canvas,
                     const TextRunPaintInfo& runInfo,
                     const FloatPoint& point,
                     float deviceScaleFactor,
-                    const SkPaint& paint) const {
+                    const PaintFlags& paint) const {
   // Don't draw anything while we are using custom fonts that are in the process
   // of loading.
   if (shouldSkipDrawing())
     return false;
 
   if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
     // we have a pre-cached blob -- happy joy!
     canvas->drawTextBlob(runInfo.cachedTextBlob->get(), point.x(), point.y(),
                          paint);
     return true;
   }
 
   GlyphBuffer glyphBuffer;
   buildGlyphBuffer(runInfo, glyphBuffer);
 
   drawGlyphBuffer(canvas, paint, runInfo, glyphBuffer, point,
                   deviceScaleFactor);
   return true;
 }
 
-bool Font::drawBidiText(SkCanvas* canvas,
+bool Font::drawBidiText(PaintCanvas* canvas,
                         const TextRunPaintInfo& runInfo,
                         const FloatPoint& point,
                         CustomFontNotReadyAction customFontNotReadyAction,
                         float deviceScaleFactor,
-                        const SkPaint& paint) const {
+                        const PaintFlags& paint) const {
   // Don't draw anything while we are using custom fonts that are in the process
   // of loading, except if the 'force' argument is set to true (in which case it
   // will use a fallback font).
   if (shouldSkipDrawing() &&
       customFontNotReadyAction == DoNotPaintIfFontNotReady)
     return false;
 
   // sub-run painting is not supported for Bidi text.
   const TextRun& run = runInfo.run;
   ASSERT((runInfo.from == 0) && (runInfo.to == run.length()));
@@ skipping 29 matching lines @@
                     deviceScaleFactor);
 
     bidiRun = bidiRun->next();
     currPoint.move(runWidth, 0);
   }
 
   bidiRuns.deleteRuns();
   return true;
 }
 
-void Font::drawEmphasisMarks(SkCanvas* canvas,
+void Font::drawEmphasisMarks(PaintCanvas* canvas,
                              const TextRunPaintInfo& runInfo,
                              const AtomicString& mark,
                              const FloatPoint& point,
                              float deviceScaleFactor,
-                             const SkPaint& paint) const {
+                             const PaintFlags& paint) const {
   if (shouldSkipDrawing())
     return;
 
   FontCachePurgePreventer purgePreventer;
 
   GlyphData emphasisGlyphData;
   if (!getEmphasisMarkGlyphData(mark, emphasisGlyphData))
     return;
 
   ASSERT(emphasisGlyphData.fontData);
@@ skipping 89 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) {
-    SkPaint paint;
+    PaintFlags paint;
     fontData->platformData().setupPaint(&paint, m_deviceScaleFactor, m_font);
-    paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+    paint.setTextEncoding(PaintFlags::kGlyphID_TextEncoding);
 
     const SkTextBlobBuilder::RunBuffer& buffer =
         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) {
@@ skipping 22 matching lines @@
 
   SkTextBlobBuilder m_builder;
   unsigned m_index;
   unsigned m_endIndex;
   unsigned m_blobCount;
   BlobRotation m_rotation;
 };
 
 }  // anonymous namespace
 
-void Font::drawGlyphBuffer(SkCanvas* canvas,
-                           const SkPaint& paint,
+void Font::drawGlyphBuffer(PaintCanvas* canvas,
+                           const PaintFlags& paint,
                            const TextRunPaintInfo& runInfo,
                            const GlyphBuffer& glyphBuffer,
                            const FloatPoint& point,
                            float deviceScaleFactor) const {
   GlyphBufferBloberizer bloberizer(glyphBuffer, this, deviceScaleFactor);
   std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
 
   while (!bloberizer.done()) {
     blob = bloberizer.next();
     ASSERT(blob.first);
 
-    SkAutoCanvasRestore autoRestore(canvas, false);
+    PaintCanvasAutoRestore autoRestore(canvas, false);
     if (blob.second == CCWRotation) {
       canvas->save();
 
       SkMatrix m;
       m.setSinCos(-1, 0, point.x(), point.y());
       canvas->concat(m);
     }
 
     canvas->drawTextBlob(blob.first, point.x(), point.y(), paint);
   }
 
   // Cache results when
   //   1) requested by clients, and
   //   2) the glyph buffer is encoded as a single blob, and
   //   3) the blob is not upright/rotated
   if (runInfo.cachedTextBlob && bloberizer.blobCount() == 1 &&
       blob.second == NoRotation) {
     ASSERT(!*runInfo.cachedTextBlob);
     *runInfo.cachedTextBlob = std::move(blob.first);
     ASSERT(*runInfo.cachedTextBlob);
   }
 }
 
 static int getInterceptsFromBloberizer(const GlyphBuffer& glyphBuffer,
                                        const Font* font,
-                                       const SkPaint& paint,
+                                       const PaintFlags& 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);
   std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
 
   int numIntervals = 0;
   while (!bloberizer.done()) {
     blob = bloberizer.next();
@@ skipping 10 matching lines @@
     if (interceptsBuffer)
       offsetInterceptsBuffer = &interceptsBuffer[numIntervals];
     numIntervals += paint.getTextBlobIntercepts(blob.first.get(), boundsArray,
                                                 offsetInterceptsBuffer);
   }
   return numIntervals;
 }
 
 void Font::getTextIntercepts(const TextRunPaintInfo& runInfo,
                              float deviceScaleFactor,
-                             const SkPaint& paint,
+                             const PaintFlags& paint,
                              const std::tuple<float, float>& bounds,
                              Vector<TextIntercept>& intercepts) const {
   if (shouldSkipDrawing())
     return;
 
   if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
     SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
     int numIntervals = paint.getTextBlobIntercepts(
         runInfo.cachedTextBlob->get(), boundsArray, nullptr);
     if (!numIntervals)
@@ skipping 191 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink