ChangeLog

2012-04-01  Koji Ishii  <kojiishi@gmail.com>

        Cache support for OpenTypeVerticalData

        https://bugs.webkit.org/show_bug.cgi?id=81332

        This patch adds FontCache to cache OpenTypeVerticalData class

        instances that was introduced in bug 81326.

        We need one instance of the class per OpenType font file, and we don't

        have a class to hold such instances today.

        ENABLE_OPENTYPE_VERTICAL isn't enabled for any platforms yet, so this

        patch isn't on any code path. Apple Windows port (bug 48459) is going

        to use this code, and probably Chromium (51450, 69282) as well.

        "FIXME" comment in SimpleFontData.h will be implemented in 48459.

        Reviewed by NOBODY (OOPS!).

        No new tests are required. No behavior changes.

        * platform/graphics/FontCache.cpp:

        (WebCore::FontCache::getCachedFontPlatformData): Ignore leading "@" on Windows to disable Windows feature for vertical flow.

        (WebCore):

        (WebCore::FontCache::getVerticalData): Get cached OpenTypeVerticalData from FontPlatformData, or crete one.

        (WebCore::FontCache::purgeInactiveFontData): Purge inactive OpenTypeVerticalData.

        * platform/graphics/FontCache.h:

        (WebCore):

        * platform/graphics/SimpleFontData.h:

        (SimpleFontData):

        (WebCore::SimpleFontData::verticalData): A dummy implementation for purgeInactiveFontData() to work.

        * platform/graphics/opentype/OpenTypeVerticalData.h: Added m_inFontCache for mark & sweep.

        (OpenTypeVerticalData):

2012-03-30  Koji Ishii  <kojiishi@gmail.com>

        Vertical alternate glyph (GSUB) support for OpenTypeVerticalData

Source/WebCore/platform/graphics/FontCache.cpp

#include "FontPlatformData.h"

#include "FontSelector.h"

#include "GlyphPageTreeNode.h"

#if ENABLE(OPENTYPE_VERTICAL)

#include "OpenTypeVerticalData.h"

#endif

#include "WebKitFontFamilyNames.h"

#include <wtf/HashMap.h>

#include <wtf/ListHashSet.h>

#include <wtf/StdLibExtras.h>

45#include <wtf/text/AtomicStringHash.h>

#include <wtf/text/StringHash.h>

using namespace WTF;

@@FontPlatformData* FontCache::getCachedFontPlatformData(const FontDescription& fo

                                                       const AtomicString& familyName,

                                                       bool checkingAlternateName)

{

#if OS(WINDOWS) && ENABLE(OPENTYPE_VERTICAL)

    // Leading "@" in the font name enables Windows vertical flow flag for the font.

    // Because we do vertical flow by ourselves, we don't want to use the Windows feature.

    // IE disregards "@" regardless of the orientatoin, so we follow the behavior.

    if (!familyName.isEmpty() && familyName[0] == '@')

        return getCachedFontPlatformData(fontDescription, AtomicString(familyName.impl()->substring(1)), checkingAlternateName);

#endif

    if (!gFontPlatformDataCache) {

        gFontPlatformDataCache = new FontPlatformDataCache;

        platformInit();

@@FontPlatformData* FontCache::getCachedFontPlatformData(const FontDescription& fo

    return result;

}

#if ENABLE(OPENTYPE_VERTICAL)

typedef HashMap<AtomicString, OpenTypeVerticalData*> FontVerticalDataCache;

static FontVerticalDataCache* gFontVerticalDataCache = 0;

OpenTypeVerticalData* FontCache::getVerticalData(const AtomicString& key, const FontPlatformData& platformData)

{

    if (key.isEmpty())

        return 0;

    if (gFontVerticalDataCache) {

        FontVerticalDataCache::iterator result = gFontVerticalDataCache->find(key);

        if (result != gFontVerticalDataCache->end())

            return result.get()->second;

    } else

        gFontVerticalDataCache = new FontVerticalDataCache;

    OpenTypeVerticalData* verticalData = new OpenTypeVerticalData(platformData);

    if (!verticalData->isOpenType()) {

        delete verticalData;

        verticalData = 0; // Put 0 in cache to mark that this isn't an OpenType font.

    }

    gFontVerticalDataCache->set(key, verticalData);

    return verticalData;

}

#endif

struct FontDataCacheKeyHash {

    static unsigned hash(const FontPlatformData& platformData)

    {

@@void FontCache::purgeInactiveFontData(int count)

            delete gFontPlatformDataCache->take(keysToRemove[i]);

    }

#if ENABLE(OPENTYPE_VERTICAL)

    if (gFontVerticalDataCache) {

        // Mark & sweep unused verticalData

        FontVerticalDataCache::iterator verticalDataEnd = gFontVerticalDataCache->end();

        for (FontVerticalDataCache::iterator verticalData = gFontVerticalDataCache->begin(); verticalData != verticalDataEnd; ++verticalData) {

            if (verticalData->second)

                verticalData->second->m_inFontCache = false;

        }

        FontDataCache::iterator fontDataEnd = gFontDataCache->end();

        for (FontDataCache::iterator fontData = gFontDataCache->begin(); fontData != fontDataEnd; ++fontData) {

            OpenTypeVerticalData* verticalData = const_cast<OpenTypeVerticalData*>(fontData->second.first->verticalData());

            if (verticalData)

                verticalData->m_inFontCache = true;

        }

        Vector<AtomicString> keysToRemove;

        keysToRemove.reserveInitialCapacity(gFontVerticalDataCache->size());

        for (FontVerticalDataCache::iterator verticalData = gFontVerticalDataCache->begin(); verticalData != verticalDataEnd; ++verticalData) {

            if (!verticalData->second || !verticalData->second->m_inFontCache)

                keysToRemove.append(verticalData->first);

        }

        for (size_t i = 0, count = keysToRemove.size(); i < count; ++i)

            delete gFontVerticalDataCache->take(keysToRemove[i]);

    }

#endif

    isPurging = false;

}

Source/WebCore/platform/graphics/FontCache.h

@@class FontPlatformData;

class FontData;

class FontDescription;

class FontSelector;

#if ENABLE(OPENTYPE_VERTICAL)

class OpenTypeVerticalData;

#endif

class SimpleFontData;

class FontCache {

@@public:

    SimpleFontData* fontDataFromDescriptionAndLogFont(const FontDescription&, ShouldRetain, const LOGFONT& font, wchar_t* outFontFamilyName);

#endif

#if ENABLE(OPENTYPE_VERTICAL)

    OpenTypeVerticalData* getVerticalData(const AtomicString&, const FontPlatformData&);

#endif

private:

    FontCache();

    ~FontCache();

Source/WebCore/platform/graphics/SimpleFontData.h

#include "FloatRect.h"

#include "GlyphMetricsMap.h"

#include "GlyphPageTreeNode.h"

#if ENABLE(OPENTYPE_VERTICAL)

#include "OpenTypeVerticalData.h"

#endif

#include "TypesettingFeatures.h"

#include <wtf/OwnPtr.h>

#include <wtf/PassOwnPtr.h>

@@public:

    virtual ~SimpleFontData();

    const FontPlatformData& platformData() const { return m_platformData; }

#if ENABLE(OPENTYPE_VERTICAL)

    const OpenTypeVerticalData* verticalData() const { return 0; } // FIXME: implement

#endif

    SimpleFontData* smallCapsFontData(const FontDescription&) const;

    SimpleFontData* emphasisMarkFontData(const FontDescription&) const;

Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.h

@@private:

    Vector<int16_t> m_topSideBearings;

    int16_t m_defaultVertOriginY;

    HashMap<Glyph, int16_t> m_vertOriginY;

    friend class FontCache;

    bool m_inFontCache : 1;

};

} // namespace WebCore