Consolidate Glyph and GlyphBufferGlyph.

Source/platform/fonts/harfbuzz/FontHarfBuzz.cpp

 /*
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 39 matching lines @@
 {
     return false;
 }
 
 bool FontPlatformFeatures::canExpandAroundIdeographsInComplexText()
 {
     return false;
 }
 
 static void paintGlyphs(GraphicsContext* gc, const SimpleFontData* font,
-    const GlyphBufferGlyph* glyphs, unsigned numGlyphs,
+    const Glyph* glyphs, unsigned numGlyphs,
     SkPoint* pos, const FloatRect& textRect)
 {
     TextDrawingModeFlags textMode = gc->textDrawingMode();
 
     // We draw text up to two times (once for fill, once for stroke).
     if (textMode & TextModeFill) {
         SkPaint paint = gc->fillPaint();
         font->platformData().setupPaint(&paint, gc);
         gc->adjustTextRenderMode(&paint);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
-        gc->drawPosText(glyphs, numGlyphs << 1, pos, textRect, paint);
+        gc->drawPosText(glyphs, numGlyphs * sizeof(Glyph), pos, textRect, paint);
     }
 
     if ((textMode & TextModeStroke)
         && gc->strokeStyle() != NoStroke
         && gc->strokeThickness() > 0) {
 
         SkPaint paint = gc->strokePaint();
         font->platformData().setupPaint(&paint, gc);
         gc->adjustTextRenderMode(&paint);
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
         if (textMode & TextModeFill) {
             // If there is a shadow and we filled above, there will already be
             // a shadow. We don't want to draw it again or it will be too dark
             // and it will go on top of the fill.
             //
             // Note that this isn't strictly correct, since the stroke could be
             // very thick and the shadow wouldn't account for this. The "right"
             // thing would be to draw to a new layer and then draw that layer
             // with a shadow. But this is a lot of extra work for something
             // that isn't normally an issue.
             paint.setLooper(0);
         }
 
-        gc->drawPosText(glyphs, numGlyphs << 1, pos, textRect, paint);
+        gc->drawPosText(glyphs, numGlyphs * sizeof(Glyph), pos, textRect, paint);
     }
 }
 
 void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font,
     const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs,
     const FloatPoint& point, const FloatRect& textRect) const
 {
-    SkASSERT(sizeof(GlyphBufferGlyph) == sizeof(uint16_t)); // compile-time assert
-
     SkScalar x = SkFloatToScalar(point.x());
     SkScalar y = SkFloatToScalar(point.y());
 
     SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
     SkPoint* pos = storage.get();
 
     const OpenTypeVerticalData* verticalData = font->verticalData();
     if (font->platformData().orientation() == Vertical && verticalData) {
         AffineTransform savedMatrix = gc->getCTM();
         gc->concatCTM(AffineTransform(0, -1, 1, 0, point.x(), point.y()));
         gc->concatCTM(AffineTransform(1, 0, 0, 1, -point.x(), -point.y()));
 
         const unsigned kMaxBufferLength = 256;
         Vector<FloatPoint, kMaxBufferLength> translations;
 
         const FontMetrics& metrics = font->fontMetrics();
         SkScalar verticalOriginX = SkFloatToScalar(point.x() + metrics.floatAscent() - metrics.floatAscent(IdeographicBaseline));
         float horizontalOffset = point.x();
 
         unsigned glyphIndex = 0;
         while (glyphIndex < numGlyphs) {
             unsigned chunkLength = std::min(kMaxBufferLength, numGlyphs - glyphIndex);
 
-            const GlyphBufferGlyph* glyphs = glyphBuffer.glyphs(from + glyphIndex);
+            const Glyph* glyphs = glyphBuffer.glyphs(from + glyphIndex);
             translations.resize(chunkLength);
             verticalData->getVerticalTranslationsForGlyphs(font, &glyphs[0], chunkLength, reinterpret_cast<float*>(&translations[0]));
 
             x = verticalOriginX;
             y = SkFloatToScalar(point.y() + horizontalOffset - point.x());
 
             float currentWidth = 0;
             for (unsigned i = 0; i < chunkLength; ++i, ++glyphIndex) {
                 pos[i].set(
                     x + SkIntToScalar(lroundf(translations[i].x())),
@@ skipping 14 matching lines @@
     // text drawing can proceed faster. However, it's unclear when those
     // patches may be upstreamed to WebKit so we always use the slower path
     // here.
     const GlyphBufferAdvance* adv = glyphBuffer.advances(from);
     for (unsigned i = 0; i < numGlyphs; i++) {
         pos[i].set(x, y);
         x += SkFloatToScalar(adv[i].width());
         y += SkFloatToScalar(adv[i].height());
     }
 
-    const GlyphBufferGlyph* glyphs = glyphBuffer.glyphs(from);
+    const Glyph* glyphs = glyphBuffer.glyphs(from);
     paintGlyphs(gc, font, glyphs, numGlyphs, pos, textRect);
 }
 
 void Font::drawComplexText(GraphicsContext* gc, const TextRunPaintInfo& runInfo, const FloatPoint& point) const
 {
     if (!runInfo.run.length())
         return;
 
     TextDrawingModeFlags textMode = gc->textDrawingMode();
     bool fill = textMode & TextModeFill;
@@ skipping 62 matching lines @@
                                             const FloatPoint& point, int height,
                                             int from, int to) const
 {
     HarfBuzzShaper shaper(this, run);
     if (!shaper.shape())
         return FloatRect();
     return shaper.selectionRect(point, height, from, to);
 }
 
 } // namespace WebCore