third_party/WebKit/Source/platform/fonts/GlyphPage.h - chromium/src - Git at Google

 /*
  * 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  *     its contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * 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 "wtf/Allocator.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/allocator/Partitions.h"
 #include "wtf/text/Unicode.h"
 #include <string.h>

 namespace blink {

 class SimpleFontData;
 class GlyphPageTreeNodeBase;

 // Holds the glyph index and the corresponding SimpleFontData information for a
 // given character.
 struct GlyphData {
   DISALLOW_NEW();
   GlyphData(Glyph g = 0, const SimpleFontData* f = 0) : glyph(g), fontData(f) {}
   Glyph glyph;
   const SimpleFontData* fontData;
 };

 #if COMPILER(MSVC)
 #pragma warning(push)
 #pragma warning( \
     disable : 4200)  // Disable "zero-sized array in struct/union" warning
 #endif

 // A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous
 // range of characters in the Unicode code space. GlyphPages are indexed
 // starting from 0 and incrementing for each 256 glyphs.
 //
 // One page may actually include glyphs from other fonts if the characters are
 // missing in the primary font. It is owned by exactly one GlyphPageTreeNode,
 // although multiple nodes may reference it as their "page" if they are supposed
 // to be overriding the parent's node, but provide no additional information.
 class PLATFORM_EXPORT GlyphPage : public RefCounted<GlyphPage> {
  public:
   static PassRefPtr<GlyphPage> createForMixedFontData(
       GlyphPageTreeNodeBase* owner) {
     void* slot = WTF::Partitions::fastMalloc(
         sizeof(GlyphPage) + sizeof(SimpleFontData*) * GlyphPage::size,
         WTF_HEAP_PROFILER_TYPE_NAME(GlyphPage));
     return adoptRef(new (slot) GlyphPage(owner));
   }

   static PassRefPtr<GlyphPage> createForSingleFontData(
       GlyphPageTreeNodeBase* owner,
       const SimpleFontData* fontData) {
     ASSERT(fontData);
     return adoptRef(new GlyphPage(owner, fontData));
   }

   PassRefPtr<GlyphPage> createCopiedSystemFallbackPage(
       GlyphPageTreeNodeBase* owner) const {
     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 {
     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];
   }

   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);

     if (hasPerGlyphFontData()) {
       m_perGlyphFontData[index] = fontData;
     } else {
       // 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 removePerGlyphFontData(const SimpleFontData* fontData) {
     // This method should only be called on the mixed 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;
       }
     }
   }

   GlyphPageTreeNodeBase* owner() const { return m_owner; }

   bool hasPerGlyphFontData() const { return !m_fontDataForAllGlyphs; }

  private:
   explicit GlyphPage(GlyphPageTreeNodeBase* 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);
   }

   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;
   GlyphPageTreeNodeBase* 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 blink

 #endif  // 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.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
	* its contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* 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 "wtf/Allocator.h"
	#include "wtf/PassRefPtr.h"
	#include "wtf/RefCounted.h"
	#include "wtf/RefPtr.h"
	#include "wtf/allocator/Partitions.h"
	#include "wtf/text/Unicode.h"
	#include <string.h>

	namespace blink {

	class SimpleFontData;
	class GlyphPageTreeNodeBase;

	// Holds the glyph index and the corresponding SimpleFontData information for a
	// given character.
	struct GlyphData {
	DISALLOW_NEW();
	GlyphData(Glyph g = 0, const SimpleFontData* f = 0) : glyph(g), fontData(f) {}
	Glyph glyph;
	const SimpleFontData* fontData;
	};

	#if COMPILER(MSVC)
	#pragma warning(push)
	#pragma warning( \
	disable : 4200) // Disable "zero-sized array in struct/union" warning
	#endif

	// A GlyphPage contains a fixed-size set of GlyphData mappings for a contiguous
	// range of characters in the Unicode code space. GlyphPages are indexed
	// starting from 0 and incrementing for each 256 glyphs.
	//
	// One page may actually include glyphs from other fonts if the characters are
	// missing in the primary font. It is owned by exactly one GlyphPageTreeNode,
	// although multiple nodes may reference it as their "page" if they are supposed
	// to be overriding the parent's node, but provide no additional information.
	class PLATFORM_EXPORT GlyphPage : public RefCounted<GlyphPage> {
	public:
	static PassRefPtr<GlyphPage> createForMixedFontData(
	GlyphPageTreeNodeBase* owner) {
	void* slot = WTF::Partitions::fastMalloc(
	sizeof(GlyphPage) + sizeof(SimpleFontData) GlyphPage::size,
	WTF_HEAP_PROFILER_TYPE_NAME(GlyphPage));
	return adoptRef(new (slot) GlyphPage(owner));
	}

	static PassRefPtr<GlyphPage> createForSingleFontData(
	GlyphPageTreeNodeBase* owner,
	const SimpleFontData* fontData) {
	ASSERT(fontData);
	return adoptRef(new GlyphPage(owner, fontData));
	}

	PassRefPtr<GlyphPage> createCopiedSystemFallbackPage(
	GlyphPageTreeNodeBase* owner) const {
	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 {
	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];
	}

	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);

	if (hasPerGlyphFontData()) {
	m_perGlyphFontData[index] = fontData;
	} else {
	// 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 removePerGlyphFontData(const SimpleFontData* fontData) {
	// This method should only be called on the mixed 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;
	}
	}
	}

	GlyphPageTreeNodeBase* owner() const { return m_owner; }

	bool hasPerGlyphFontData() const { return !m_fontDataForAllGlyphs; }

	private:
	explicit GlyphPage(GlyphPageTreeNodeBase* 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);
	}

	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;
	GlyphPageTreeNodeBase* 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 blink

	#endif // GlyphPage_h