Shape unicode-range: font faces in only one iteration

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzFace.cpp

 /*
  * Copyright (c) 2012 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 25 matching lines @@
 #include "hb-coretext.h"
 #endif
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPoint.h"
 #include "SkRect.h"
 #include "SkTypeface.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontPlatformData.h"
 #include "platform/fonts/SimpleFontData.h"
+#include "platform/fonts/UnicodeRangeSet.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "wtf/HashMap.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 const hb_tag_t HarfBuzzFace::vertTag = HB_TAG('v', 'e', 'r', 't');
 
 // Though we have FontCache class, which provides the cache mechanism for
 // WebKit's font objects, we also need additional caching layer for HarfBuzz
@@ skipping 51 matching lines @@
     ASSERT(result.get()->value->refCount() > 1);
     result.get()->value->deref();
     if (result.get()->value->refCount() == 1)
         harfBuzzFaceCache()->remove(m_uniqueID);
 }
 
 struct HarfBuzzFontData {
     USING_FAST_MALLOC(HarfBuzzFontData);
     WTF_MAKE_NONCOPYABLE(HarfBuzzFontData);
 public:
-    HarfBuzzFontData(WTF::HashMap<uint32_t, uint16_t>* glyphCacheForFaceCacheEntry, hb_face_t* face, unsigned rangeFrom, unsigned rangeTo)
+    HarfBuzzFontData(WTF::HashMap<uint32_t, uint16_t>* glyphCacheForFaceCacheEntry, hb_face_t* face, PassRefPtr<UnicodeRangeSet> rangeSet)
         : m_glyphCacheForFaceCacheEntry(glyphCacheForFaceCacheEntry)
         , m_face(face)
         , m_hbOpenTypeFont(nullptr)
-        , m_rangeFrom(rangeFrom)
-        , m_rangeTo(rangeTo)
-    { }
+        , m_rangeSet(rangeSet)
+    {
+    }
 
     ~HarfBuzzFontData()
     {
         if (m_hbOpenTypeFont)
             hb_font_destroy(m_hbOpenTypeFont);
     }
 
     SkPaint m_paint;
     RefPtr<SimpleFontData> m_simpleFontData;
     WTF::HashMap<uint32_t, uint16_t>* m_glyphCacheForFaceCacheEntry;
     hb_face_t* m_face;
     hb_font_t* m_hbOpenTypeFont;
-    unsigned m_rangeFrom;
-    unsigned m_rangeTo;
+    RefPtr<UnicodeRangeSet> m_rangeSet;
 };
 
 static hb_position_t SkiaScalarToHarfBuzzPosition(SkScalar value)
 {
     // We treat HarfBuzz hb_position_t as 16.16 fixed-point.
     static const int kHbPosition1 = 1 << 16;
     return clampTo<int>(value * kHbPosition1);
 }
 
 static void SkiaGetGlyphWidthAndExtents(SkPaint* paint, hb_codepoint_t codepoint, hb_position_t* width, hb_glyph_extents_t* extents)
@@ skipping 29 matching lines @@
 
 #if !defined(HB_VERSION_ATLEAST)
 #define HB_VERSION_ATLEAST(major, minor, micro) 0
 #endif
 
 static hb_bool_t harfBuzzGetGlyph(hb_font_t* hbFont, void* fontData, hb_codepoint_t unicode, hb_codepoint_t variationSelector, hb_codepoint_t* glyph, void* userData)
 {
     HarfBuzzFontData* hbFontData = reinterpret_cast<HarfBuzzFontData*>(fontData);
 
     RELEASE_ASSERT(hbFontData);
-    if (unicode < hbFontData->m_rangeFrom || unicode > hbFontData->m_rangeTo)
+    if (hbFontData->m_rangeSet && !hbFontData->m_rangeSet->contains(unicode))
         return false;
 
     if (variationSelector) {
 #if !HB_VERSION_ATLEAST(0, 9, 28)
         return false;
 #else
         // Skia does not support variation selectors, but hb does.
         // We're not fully ready to switch to hb-ot-font yet,
         // but are good enough to get glyph IDs for OpenType fonts.
         if (!hbFontData->m_hbOpenTypeFont) {
@@ skipping 145 matching lines @@
 {
 #if OS(MACOSX)
     hb_face_t* face = hb_coretext_face_create(m_platformData->cgFont());
 #else
     hb_face_t* face = hb_face_create_for_tables(harfBuzzSkiaGetTable, m_platformData->typeface(), 0);
 #endif
     ASSERT(face);
     return face;
 }
 
-hb_font_t* HarfBuzzFace::createFont(unsigned rangeFrom, unsigned rangeTo) const
+hb_font_t* HarfBuzzFace::createFont(PassRefPtr<UnicodeRangeSet> rangeSet) const
 {
-    HarfBuzzFontData* hbFontData = new HarfBuzzFontData(m_glyphCacheForFaceCacheEntry, m_face, rangeFrom, rangeTo);
+    HarfBuzzFontData* hbFontData = new HarfBuzzFontData(m_glyphCacheForFaceCacheEntry, m_face, rangeSet);
     m_platformData->setupPaint(&hbFontData->m_paint);
     hbFontData->m_simpleFontData = FontCache::fontCache()->fontDataFromFontPlatformData(m_platformData);
     ASSERT(hbFontData->m_simpleFontData);
     hb_font_t* font = hb_font_create(m_face);
     hb_font_set_funcs(font, harfBuzzSkiaGetFontFuncs(), hbFontData, destroyHarfBuzzFontData);
     float size = m_platformData->size();
     int scale = SkiaScalarToHarfBuzzPosition(size);
     hb_font_set_scale(font, scale, scale);
     hb_font_make_immutable(font);
     return font;
 }
 
 } // namespace blink