[TextBlob] Add support for offsets (i.e. complex text) to text blobs.

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 253 matching lines @@
 #if ENABLE(SVG_FONTS)
     if (TextRun::RenderingContext* renderingContext = run.renderingContext())
         return renderingContext->floatWidthUsingSVGFont(*this, run, charsConsumed, glyphId);
 #endif
 
     charsConsumed = run.length();
     glyphId = 0;
     return width(run);
 }
 
-PassTextBlobPtr Font::buildTextBlob(const GlyphBuffer& glyphBuffer, float initialAdvance,
-    const FloatRect& bounds, bool couldUseLCD) const
+namespace {
+
+template <bool hasOffsets>
+bool buildTextBlobInternal(const GlyphBuffer& glyphBuffer, SkScalar initialAdvance,
+    const SkRect* bounds, bool couldUseLCD, SkTextBlobBuilder& builder)
 {
-    ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
-
-    // FIXME: Implement the more general full-positioning path for complex text support.
-    if (glyphBuffer.hasOffsets())
-        return nullptr;
-
-    SkTextBlobBuilder builder;
-    SkScalar x = SkFloatToScalar(initialAdvance);
-    SkRect skBounds = bounds;
-
+    SkScalar x = initialAdvance;
     unsigned i = 0;
     while (i < glyphBuffer.size()) {
         const SimpleFontData* fontData = glyphBuffer.fontDataAt(i);
 
         // FIXME: Handle vertical text.
         if (fontData->platformData().orientation() == Vertical)
-            return nullptr;
+            return false;
 
         // FIXME: Handle SVG fonts.
         if (fontData->isSVGFont())
-            return nullptr;
+            return false;
 
         // FIXME: FontPlatformData makes some decisions on the device scale
         // factor, which is found via the GraphicsContext. This should be fixed
         // to avoid correctness problems here.
         SkPaint paint;
         fontData->platformData().setupPaint(&paint);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
         // FIXME: this should go away after the big LCD cleanup.
         paint.setLCDRenderText(paint.isLCDRenderText() && couldUseLCD);
 
         unsigned start = i++;
         while (i < glyphBuffer.size() && glyphBuffer.fontDataAt(i) == fontData)
             i++;
         unsigned count = i - start;
 
-        const SkTextBlobBuilder::RunBuffer& buffer = builder.allocRunPosH(paint, count, 0, &skBounds);
+        const SkTextBlobBuilder::RunBuffer& buffer = hasOffsets ?
+            builder.allocRunPos(paint, count, bounds) :
+            builder.allocRunPosH(paint, count, 0, bounds);
 
         const uint16_t* glyphs = glyphBuffer.glyphs(start);
         std::copy(glyphs, glyphs + count, buffer.glyphs);
 
         const float* advances = glyphBuffer.advances(start);
+        const FloatSize* offsets = glyphBuffer.offsets(start);
         for (unsigned j = 0; j < count; j++) {
-            buffer.pos[j] = x;
+            if (hasOffsets) {
+                const FloatSize& offset = offsets[j];
+                buffer.pos[2 * j] = x + offset.width();
+                buffer.pos[2 * j + 1] = offset.height();
+            } else {
+                buffer.pos[j] = x;
+            }
             x += SkFloatToScalar(advances[j]);
         }
     }
+    return true;
+}
 
-    return adoptRef(builder.build());
+} // namespace
+
+PassTextBlobPtr Font::buildTextBlob(const GlyphBuffer& glyphBuffer, float initialAdvance,
+    const FloatRect& bounds, bool couldUseLCD) const
+{
+    ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
+
+    SkTextBlobBuilder builder;
+    SkScalar advance = SkFloatToScalar(initialAdvance);
+    SkRect skBounds = bounds;
+
+    bool success = glyphBuffer.hasOffsets() ?
+        buildTextBlobInternal<true>(glyphBuffer, advance, &skBounds, couldUseLCD, builder) :
+        buildTextBlobInternal<false>(glyphBuffer, advance, &skBounds, couldUseLCD, builder);
+    return success ? adoptRef(builder.build()) : nullptr;
 }
 
 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 775 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink