Replace glyph find and position with common code for the gpu bitmap case.

src/core/SkFindAndPlaceGlyph.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFindAndPositionGlyph_DEFINED
 #define SkFindAndPositionGlyph_DEFINED
 
@@ skipping 35 matching lines @@
     //   to a whole coordinate instead of using sub-pixel positioning.
     // The number of variations is 108 for sub-pixel and 36 for full-pixel.
     // This routine handles all of them using inline polymorphic variable (no heap allocation).
     template<typename ProcessOneGlyph>
     static void ProcessPosText(const char text[], size_t byteLength,
                                const SkPoint& offset, const SkMatrix& matrix,
                                const SkScalar pos[], int scalarsPerPosition,
                                SkPaint::Align textAlignment, SkDrawCacheProc& glyphCacheProc,
                                SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph);
 
-    // SpecializedProcessPosText is a version of ProcessPosText that de-virtualizes the
-    // different components used. It returns true if it can handle the situation, otherwise it
-    // returns false. This allows greater inlining freedom to the compiler. Currently, there is
-    // only one specialized variant: sub-pixel position, left-aligned, x-axis-aligned,
-    // translation, and one scalar per position entry.
-    // * This is by far the most common type of text Blink draws.
-    template<typename ProcessOneGlyph>
-    static bool SpecializedProcessPosText(const char* const text, size_t byteLength,
-                                          const SkPoint& offset, const SkMatrix& matrix,
-                                          const SkScalar pos[], int scalarsPerPosition,
-                                          SkPaint::Align textAlignment,
-                                          SkDrawCacheProc& glyphCacheProc,
-                                          SkGlyphCache* cache,
-                                          ProcessOneGlyph&& processOneGlyph);
-
 private:
     // UntaggedVariant is a pile of memory that can hold one of the Ts. It provides a way
     // to initialize that memory in a typesafe way.
     template<typename... Ts>
     class UntaggedVariant {
     public:
         UntaggedVariant() { }
 
         ~UntaggedVariant() { }
         UntaggedVariant(const UntaggedVariant&) = delete;
@@ skipping 329 matching lines @@
         }
     }
 };
 
 template<typename ProcessOneGlyph>
 inline void SkFindAndPlaceGlyph::ProcessPosText(
     const char text[], size_t byteLength, const SkPoint& offset, const SkMatrix& matrix,
     const SkScalar pos[], int scalarsPerPosition, SkPaint::Align textAlignment,
     SkDrawCacheProc& glyphCacheProc, SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph) {
 
+    SkAxisAlignment axisAlignment = SkComputeAxisAlignmentForHText(matrix);
+    uint32_t mtype = matrix.getType();
+
+    // Specialized code for handling the most common case for blink. The while loop is totally
+    // de-virtualized.
+    if (scalarsPerPosition == 1
+        && textAlignment == SkPaint::kLeft_Align
+        && axisAlignment == kX_SkAxisAlignment
+        && cache->isSubpixel()
+        && mtype <= SkMatrix::kTranslate_Mask) {
+        typedef GlyphFindAndPlaceSubpixel<
+            ProcessOneGlyph, SkPaint::kLeft_Align, kX_SkAxisAlignment> Positioner;
+        HorizontalPositions positions{pos};
+        TranslationMapper mapper{matrix, offset};
+        Positioner positioner(cache, glyphCacheProc);
+        const char* cursor = text;
+        const char* stop = text + byteLength;
+        while (cursor < stop) {
+            SkPoint mappedPoint = mapper.TranslationMapper::map(
+                positions.HorizontalPositions::nextPoint());
+            positioner.Positioner::findAndPositionGlyph(
+                &cursor, mappedPoint, skstd::forward<ProcessOneGlyph>(processOneGlyph));
+        }
+        return;
+    }
+
     PositionReader positionReader{
         [&](PositionReader::Variants* to_init) {
             if (2 == scalarsPerPosition) {
                 to_init->initialize<ArbitraryPositions>(pos);
             } else {
                 to_init->initialize<HorizontalPositions>(pos);
             }
         }
     };
 
     Mapper mapper{
         [&](Mapper::Variants* to_init) {
-            uint32_t mtype = matrix.getType();
             if (mtype & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)
                 || scalarsPerPosition == 2) {
                 to_init->initialize<GeneralMapper>(matrix, offset);
             } else if (mtype & SkMatrix::kScale_Mask) {
                 to_init->initialize<XScaleMapper>(matrix, offset);
             } else {
                 to_init->initialize<TranslationMapper>(matrix, offset);
             }
         }
     };
 
     GlyphFindAndPlace<ProcessOneGlyph> findAndPosition{
         [&](typename GlyphFindAndPlace<ProcessOneGlyph>::Variants* to_init) {
             if (cache->isSubpixel()) {
-                SkAxisAlignment axisAlignment = SkComputeAxisAlignmentForHText(matrix);
                 switch (textAlignment) {
                     case SkPaint::kLeft_Align:
                         InitSubpixel<ProcessOneGlyph, SkPaint::kLeft_Align>(
                             to_init, axisAlignment, cache, glyphCacheProc);
                         break;
                     case SkPaint::kCenter_Align:
                         InitSubpixel<ProcessOneGlyph, SkPaint::kCenter_Align>(
                             to_init, axisAlignment, cache, glyphCacheProc);
                         break;
                     case SkPaint::kRight_Align:
@@ skipping 24 matching lines @@
     };
 
     const char* stop = text + byteLength;
     while (text < stop) {
         SkPoint mappedPoint = mapper->map(positionReader->nextPoint());
         findAndPosition->findAndPositionGlyph(
             &text, mappedPoint, skstd::forward<ProcessOneGlyph>(processOneGlyph));
     }
 }
 
-template<typename ProcessOneGlyph>
-inline bool SkFindAndPlaceGlyph::SpecializedProcessPosText(
-    const char* const text, size_t byteLength, const SkPoint& offset, const SkMatrix& matrix,
-    const SkScalar pos[], int scalarsPerPosition, SkPaint::Align textAlignment,
-    SkDrawCacheProc& glyphCacheProc, SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph) {
-    SkAxisAlignment axisAlignment = SkComputeAxisAlignmentForHText(matrix);
-    uint32_t mtype = matrix.getType();
-    if (scalarsPerPosition == 1
-        && textAlignment == SkPaint::kLeft_Align
-        && axisAlignment == kX_SkAxisAlignment
-        && cache->isSubpixel()
-        && mtype <= SkMatrix::kTranslate_Mask) {
-        typedef GlyphFindAndPlaceSubpixel<
-        ProcessOneGlyph, SkPaint::kLeft_Align, kX_SkAxisAlignment> Positioner;
-        HorizontalPositions positions{pos};
-        TranslationMapper mapper{matrix, offset};
-        Positioner positioner(cache, glyphCacheProc);
-        const char* cursor = text;
-        const char* stop = text + byteLength;
-        while (cursor < stop) {
-            SkPoint mappedPoint = mapper.TranslationMapper::map(
-                positions.HorizontalPositions::nextPoint());
-            positioner.Positioner::findAndPositionGlyph(
-                &cursor, mappedPoint, skstd::forward<ProcessOneGlyph>(processOneGlyph));
-        }
-        return true;
-    }
-    return false;
-}
-
-
 #endif  // SkFindAndPositionGlyph_DEFINED