[NOT FOR COMMIT] Fully replace SkCanvas uses.

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 25 matching lines @@
 #include "platform/fonts/shaping/CachingWordShaper.h"
 #include "platform/geometry/FloatRect.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 "skia/ext/cdl_canvas.h"
+#include "skia/ext/cdl_paint.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
 Font::Font() : m_canShapeWordByWord(0), m_shapeWordByWordComputed(0) {}
@@ skipping 58 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(CdlCanvas* canvas,
                     const TextRunPaintInfo& runInfo,
                     const FloatPoint& point,
                     float deviceScaleFactor,
-                    const SkPaint& paint) const {
+                    const CdlPaint& 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(CdlCanvas* canvas,
                         const TextRunPaintInfo& runInfo,
                         const FloatPoint& point,
                         CustomFontNotReadyAction customFontNotReadyAction,
                         float deviceScaleFactor,
-                        const SkPaint& paint) const {
+                        const CdlPaint& 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(CdlCanvas* canvas,
                              const TextRunPaintInfo& runInfo,
                              const AtomicString& mark,
                              const FloatPoint& point,
                              float deviceScaleFactor,
-                             const SkPaint& paint) const {
+                             const CdlPaint& paint) const {
   if (shouldSkipDrawing())
     return;
 
   FontCachePurgePreventer purgePreventer;
 
   GlyphData emphasisGlyphData;
   if (!getEmphasisMarkGlyphData(mark, emphasisGlyphData))
     return;
 
   ASSERT(emphasisGlyphData.fontData);
@@ skipping 122 matching lines @@
   const bool m_hasVerticalOffsets;
 
   SkTextBlobBuilder m_builder;
   unsigned m_index;
   unsigned m_blobCount;
   BlobRotation m_rotation;
 };
 
 }  // anonymous namespace
 
-void Font::drawGlyphBuffer(SkCanvas* canvas,
-                           const SkPaint& paint,
+void Font::drawGlyphBuffer(CdlCanvas* canvas,
+                           const CdlPaint& 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);
+    CdlAutoCanvasRestore 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 CdlPaint& 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;
 
+  SkPaint skPaint = ToSkPaint(paint);
   int numIntervals = 0;
   while (!bloberizer.done()) {
     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 += paint.getTextBlobIntercepts(blob.first.get(), boundsArray,
-                                                offsetInterceptsBuffer);
+    numIntervals += skPaint.getTextBlobIntercepts(blob.first.get(), boundsArray,
+                                                  offsetInterceptsBuffer);
   }
   return numIntervals;
 }
 
 void Font::getTextIntercepts(const TextRunPaintInfo& runInfo,
                              float deviceScaleFactor,
-                             const SkPaint& paint,
+                             const CdlPaint& paint,
                              const std::tuple<float, float>& bounds,
                              Vector<TextIntercept>& intercepts) const {
   if (shouldSkipDrawing())
     return;
 
+  SkPaint skPaint = ToSkPaint(paint);
   if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
     SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
-    int numIntervals = paint.getTextBlobIntercepts(
+    int numIntervals = skPaint.getTextBlobIntercepts(
         runInfo.cachedTextBlob->get(), boundsArray, nullptr);
     if (!numIntervals)
       return;
     DCHECK_EQ(numIntervals % 2, 0);
     intercepts.resize(numIntervals / 2);
-    paint.getTextBlobIntercepts(runInfo.cachedTextBlob->get(), boundsArray,
-                                reinterpret_cast<SkScalar*>(intercepts.data()));
+    skPaint.getTextBlobIntercepts(
+        runInfo.cachedTextBlob->get(), boundsArray,
+        reinterpret_cast<SkScalar*>(intercepts.data()));
     return;
   }
 
   GlyphBuffer glyphBuffer;
   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.
   int numIntervals = getInterceptsFromBloberizer(
@@ skipping 172 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink