Proper unicode-range font loading behavior

Source/platform/fonts/GlyphPage.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2013 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef GlyphPage_h
 #define GlyphPage_h
 
 #include "platform/PlatformExport.h"
+#include "platform/fonts/CustomFontData.h"
 #include "platform/fonts/Glyph.h"
 #include <string.h>
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/unicode/Unicode.h"
 
 namespace WebCore {
 
 class SimpleFontData;
@@ skipping 42 matching lines @@
     {
         RefPtr<GlyphPage> page = GlyphPage::createForMixedFontData(owner);
         memcpy(page->m_glyphs, m_glyphs, sizeof(m_glyphs));
         if (hasPerGlyphFontData())
             memcpy(page->m_perGlyphFontData, m_perGlyphFontData, sizeof(SimpleFontData*) * GlyphPage::size);
         else {
             for (size_t i = 0; i < GlyphPage::size; ++i) {
                 page->m_perGlyphFontData[i] = m_glyphs[i] ? m_fontDataForAllGlyphs : 0;
             }
         }
+        page->m_customFontToLoad = m_customFontToLoad;
         return page.release();
     }
 
     ~GlyphPage() { }
 
     static const unsigned char sizeBits = 8;
     static const size_t size = (1 << GlyphPage::sizeBits); // Covers Latin-1 in a single page.
     static unsigned indexForCharacter(UChar32 c) { return c & 0xFF; }
 
     ALWAYS_INLINE GlyphData glyphDataForCharacter(UChar32 c) const
     {
-        return glyphDataForIndex(indexForCharacter(c));
+        unsigned index = indexForCharacter(c);
+        if (const CustomFontData* customData = customFontToLoadAt(index))
+            customData->beginLoadIfNeeded();
+        return glyphDataForIndex(index);
     }
 
     ALWAYS_INLINE GlyphData glyphDataForIndex(unsigned index) const
     {
         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
         Glyph glyph = m_glyphs[index];
         if (hasPerGlyphFontData())
             return GlyphData(glyph, m_perGlyphFontData[index]);
         return GlyphData(glyph, glyph ? m_fontDataForAllGlyphs : 0);
     }
 
     ALWAYS_INLINE Glyph glyphForCharacter(UChar32 c) const
     {
         return glyphAt(indexForCharacter(c));
     }
 
     ALWAYS_INLINE Glyph glyphAt(unsigned index) const
     {
         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
         return m_glyphs[index];
     }
 
-    ALWAYS_INLINE const SimpleFontData* fontDataForCharacter(UChar32 c) const
-    {
-        unsigned index = indexForCharacter(c);
-        if (hasPerGlyphFontData())
-            return m_perGlyphFontData[index];
-        return m_glyphs[index] ? m_fontDataForAllGlyphs : 0;
-    }
-
     void setGlyphDataForCharacter(UChar32 c, Glyph g, const SimpleFontData* f)
     {
         setGlyphDataForIndex(indexForCharacter(c), g, f);
     }
 
     void setGlyphDataForIndex(unsigned index, Glyph glyph, const SimpleFontData* fontData)
     {
         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
         m_glyphs[index] = glyph;
+        setCustomFontToLoad(index, 0);
 
         // GlyphPage getters will always return a null SimpleFontData* for glyph #0 if there's no per-glyph font array.
         if (hasPerGlyphFontData()) {
             m_perGlyphFontData[index] = glyph ? fontData : 0;
             return;
         }
 
         // A single-font GlyphPage already assigned m_fontDataForAllGlyphs in the constructor.
         ASSERT(!glyph || fontData == m_fontDataForAllGlyphs);
     }
 
     void setGlyphDataForIndex(unsigned index, const GlyphData& glyphData)
     {
         setGlyphDataForIndex(index, glyphData.glyph, glyphData.fontData);
     }
 
+    const CustomFontData* customFontToLoadAt(unsigned index) const
+    {
+        ASSERT_WITH_SECURITY_IMPLICATION(index < size);
+        return m_customFontToLoad ? m_customFontToLoad->at(index) : 0;
+    }
+
+    void setCustomFontToLoad(unsigned index, const CustomFontData* customFontToLoad)
+    {
+        if (!m_customFontToLoad) {
+            if (!customFontToLoad)
+                return;
+            m_customFontToLoad = CustomDataPage::create();
+        }
+        ASSERT_WITH_SECURITY_IMPLICATION(index < size);
+        m_customFontToLoad->set(index, customFontToLoad);
+    }
+
     void removeFontDataFromSystemFallbackPage(const SimpleFontData* fontData)
     {
         // This method should only be called on the system fallback page, which is never single-font.
         ASSERT(hasPerGlyphFontData());
         for (size_t i = 0; i < size; ++i) {
             if (m_perGlyphFontData[i] == fontData) {
                 m_glyphs[i] = 0;
                 m_perGlyphFontData[i] = 0;
             }
         }
     }
 
     GlyphPageTreeNode* owner() const { return m_owner; }
 
 private:
     explicit GlyphPage(GlyphPageTreeNode* owner, const SimpleFontData* fontDataForAllGlyphs = 0)
         : m_fontDataForAllGlyphs(fontDataForAllGlyphs)
         , m_owner(owner)
     {
         memset(m_glyphs, 0, sizeof(m_glyphs));
         if (hasPerGlyphFontData())
             memset(m_perGlyphFontData, 0, sizeof(SimpleFontData*) * GlyphPage::size);
     }
 
     bool hasPerGlyphFontData() const { return !m_fontDataForAllGlyphs; }
 
+    class CustomDataPage : public RefCounted<CustomDataPage> {
+    public:
+        static RefPtr<CustomDataPage> create() { return adoptRef(new CustomDataPage()); }
+        const CustomFontData* at(size_t index) const { return m_customData[index]; }
+        void set(size_t index, const CustomFontData* data) { m_customData[index] = data; }
+    private:
+        CustomDataPage() { memset(m_customData, 0, sizeof(m_customData)); }
+        const CustomFontData* m_customData[size];
+    };
+
     const SimpleFontData* m_fontDataForAllGlyphs;
     GlyphPageTreeNode* m_owner;
+    RefPtr<CustomDataPage> m_customFontToLoad;
     Glyph m_glyphs[size];
 
     // NOTE: This array has (GlyphPage::size) elements if m_fontDataForAllGlyphs is null.
     const SimpleFontData* m_perGlyphFontData[0];
 };
 
 #if COMPILER(MSVC)
 #pragma warning(pop)
 #endif
 
 } // namespace WebCore
 
 #endif // GlyphPage_h