Remove Simple Text Path

third_party/WebKit/Source/platform/fonts/SimpleFontData.cpp

 /*
  * Copyright (C) 2005, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov
  *
  * 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 15 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/fonts/SimpleFontData.h"
 
 #include "SkPath.h"
 #include "SkTypeface.h"
 #include "SkTypes.h"
 #include "platform/fonts/FontDescription.h"
-#include "platform/fonts/GlyphPage.h"
 #include "platform/fonts/VDMXParser.h"
 #include "platform/fonts/skia/SkiaTextMetrics.h"
 #include "platform/geometry/FloatRect.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/allocator/Partitions.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/Unicode.h"
 #include <memory>
 #include <unicode/unorm.h>
@@ skipping 233 matching lines @@
   m_spaceGlyph = glyphForCharacter(' ');
   float width = widthForGlyph(m_spaceGlyph);
   m_spaceWidth = width;
   m_zeroGlyph = glyphForCharacter('0');
   m_fontMetrics.setZeroWidth(widthForGlyph(m_zeroGlyph));
 
   m_missingGlyphData.fontData = this;
   m_missingGlyphData.glyph = 0;
 }
 
-SimpleFontData::~SimpleFontData() {
-  if (isCustomFont())
-    GlyphPageTreeNode::pruneTreeCustomFontData(this);
-  else
-    GlyphPageTreeNode::pruneTreeFontData(this);
-}
-
 const SimpleFontData* SimpleFontData::fontDataForCharacter(UChar32) const {
   return this;
 }
 
 Glyph SimpleFontData::glyphForCharacter(UChar32 codepoint) const {
   uint16_t glyph;
   SkTypeface* typeface = platformData().typeface();
   RELEASE_ASSERT(typeface);
   typeface->charsToGlyphs(&codepoint, SkTypeface::kUTF32_Encoding, &glyph, 1);
   return glyph;
 }
 
 bool SimpleFontData::isSegmented() const {
   return false;
 }
 
 PassRefPtr<SimpleFontData> SimpleFontData::verticalRightOrientationFontData()
     const {
   if (!m_derivedFontData)
-    m_derivedFontData = DerivedFontData::create(isCustomFont());
+    m_derivedFontData = DerivedFontData::create();
   if (!m_derivedFontData->verticalRightOrientation) {
     FontPlatformData verticalRightPlatformData(m_platformData);
     verticalRightPlatformData.setOrientation(FontOrientation::Horizontal);
     m_derivedFontData->verticalRightOrientation =
         create(verticalRightPlatformData,
                isCustomFont() ? CustomFontData::create() : nullptr, true);
   }
   return m_derivedFontData->verticalRightOrientation;
 }
 
 PassRefPtr<SimpleFontData> SimpleFontData::uprightOrientationFontData() const {
   if (!m_derivedFontData)
-    m_derivedFontData = DerivedFontData::create(isCustomFont());
+    m_derivedFontData = DerivedFontData::create();
   if (!m_derivedFontData->uprightOrientation)
     m_derivedFontData->uprightOrientation =
         create(m_platformData,
                isCustomFont() ? CustomFontData::create() : nullptr, true);
   return m_derivedFontData->uprightOrientation;
 }
 
 PassRefPtr<SimpleFontData> SimpleFontData::smallCapsFontData(
     const FontDescription& fontDescription) const {
   if (!m_derivedFontData)
-    m_derivedFontData = DerivedFontData::create(isCustomFont());
+    m_derivedFontData = DerivedFontData::create();
   if (!m_derivedFontData->smallCaps)
     m_derivedFontData->smallCaps =
         createScaledFontData(fontDescription, smallCapsFontSizeMultiplier);
 
   return m_derivedFontData->smallCaps;
 }
 
 PassRefPtr<SimpleFontData> SimpleFontData::emphasisMarkFontData(
     const FontDescription& fontDescription) const {
   if (!m_derivedFontData)
-    m_derivedFontData = DerivedFontData::create(isCustomFont());
+    m_derivedFontData = DerivedFontData::create();
   if (!m_derivedFontData->emphasisMark)
     m_derivedFontData->emphasisMark =
         createScaledFontData(fontDescription, emphasisMarkFontSizeMultiplier);
 
   return m_derivedFontData->emphasisMark;
 }
 
 bool SimpleFontData::isTextOrientationFallbackOf(
     const SimpleFontData* fontData) const {
   if (!isTextOrientationFallback() || !fontData->m_derivedFontData)
     return false;
   return fontData->m_derivedFontData->uprightOrientation == this ||
          fontData->m_derivedFontData->verticalRightOrientation == this;
 }
 
 std::unique_ptr<SimpleFontData::DerivedFontData>
-SimpleFontData::DerivedFontData::create(bool forCustomFont) {
-  return wrapUnique(new DerivedFontData(forCustomFont));
-}
-
-SimpleFontData::DerivedFontData::~DerivedFontData() {
-  if (!forCustomFont)
-    return;
-
-  if (smallCaps)
-    GlyphPageTreeNode::pruneTreeCustomFontData(smallCaps.get());
-  if (emphasisMark)
-    GlyphPageTreeNode::pruneTreeCustomFontData(emphasisMark.get());
-  if (verticalRightOrientation)
-    GlyphPageTreeNode::pruneTreeCustomFontData(verticalRightOrientation.get());
-  if (uprightOrientation)
-    GlyphPageTreeNode::pruneTreeCustomFontData(uprightOrientation.get());
+SimpleFontData::DerivedFontData::create() {
+  return wrapUnique(new DerivedFontData());
 }
 
 PassRefPtr<SimpleFontData> SimpleFontData::createScaledFontData(
     const FontDescription& fontDescription,
     float scaleFactor) const {
   const float scaledSize =
       lroundf(fontDescription.computedSize() * scaleFactor);
   return SimpleFontData::create(
       FontPlatformData(m_platformData, scaledSize),
       isCustomFont() ? CustomFontData::create() : nullptr);
@@ skipping 12 matching lines @@
 
 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const {
   if (!m_platformData.size())
     return 0;
 
   static_assert(sizeof(glyph) == 2, "Glyph id should not be truncated.");
 
   return SkiaTextMetrics(&m_paint).getSkiaWidthForGlyph(glyph);
 }
 
-bool SimpleFontData::fillGlyphPage(GlyphPage* pageToFill,
-                                   unsigned offset,
-                                   unsigned length,
-                                   UChar* buffer,
-                                   unsigned bufferLength) const {
-  if (U16_IS_LEAD(buffer[bufferLength - 1])) {
-    DLOG(ERROR) << "Last UTF-16 code unit is high-surrogate.";
-    return false;
-  }
-
-  SkTypeface* typeface = platformData().typeface();
-  if (!typeface) {
-    DLOG(ERROR) << "fillGlyphPage called on an empty Skia typeface.";
-    return false;
-  }
-
-  SkAutoSTMalloc<GlyphPage::size, uint16_t> glyphStorage(length);
-  uint16_t* glyphs = glyphStorage.get();
-  typeface->charsToGlyphs(buffer, SkTypeface::kUTF16_Encoding, glyphs, length);
-
-  bool haveGlyphs = false;
-  for (unsigned i = 0; i < length; i++) {
-    if (glyphs[i]) {
-      pageToFill->setGlyphDataForIndex(offset + i, glyphs[i], this);
-      haveGlyphs = true;
-    }
-  }
-
-  return haveGlyphs;
-}
-
 }  // namespace blink