Simplify exposed API of HarfBuzzShaper

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

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. 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.
@@ skipping 15 matching lines @@
  * 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.
  */
 
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/Font.h"
+#include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontFallbackIterator.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/SmallCapsIterator.h"
 #include "platform/fonts/UTF16TextIterator.h"
 #include "platform/fonts/opentype/OpenTypeCapsSupport.h"
 #include "platform/fonts/shaping/CaseMappingHarfBuzzBufferFiller.h"
 #include "platform/fonts/shaping/HarfBuzzFace.h"
 #include "platform/fonts/shaping/RunSegmenter.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
 #include "platform/text/Character.h"
 #include "platform/text/TextBreakIterator.h"
 #include "wtf/Compiler.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Unicode.h"
 #include <algorithm>
 #include <hb.h>
 #include <memory>
 #include <unicode/uchar.h>
 #include <unicode/uscript.h>
 
 namespace blink {
+using FeaturesVector = Vector<hb_feature_t, 6>;
 
 template <typename T>
 class HarfBuzzScopedPtr {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(HarfBuzzScopedPtr);
 
  public:
   typedef void (*DestroyFunction)(T*);
 
   HarfBuzzScopedPtr(T* ptr, DestroyFunction destroy)
@@ skipping 78 matching lines @@
     const SimpleFontData* fontData) {
   hb_direction_t harfBuzzDirection =
       isVerticalAnyUpright(orientation) &&
               !fontData->isTextOrientationFallback()
           ? HB_DIRECTION_TTB
           : HB_DIRECTION_LTR;
   return dir == RTL ? HB_DIRECTION_REVERSE(harfBuzzDirection)
                     : harfBuzzDirection;
 }
 
-}  // namespace
-
-inline bool HarfBuzzShaper::shapeRange(
-    hb_buffer_t* harfBuzzBuffer,
-    const Font* font,
-    const FeaturesVector& fontFeatures,
-    const SimpleFontData* currentFont,
-    PassRefPtr<UnicodeRangeSet> currentFontRangeSet,
-    UScriptCode currentRunScript,
-    hb_language_t language) {
+inline bool shapeRange(hb_buffer_t* harfBuzzBuffer,
+                       hb_feature_t* fontFeatures,
+                       unsigned fontFeaturesSize,
+                       const SimpleFontData* currentFont,
+                       PassRefPtr<UnicodeRangeSet> currentFontRangeSet,
+                       UScriptCode currentRunScript,
+                       hb_direction_t direction,
+                       hb_language_t language) {
   const FontPlatformData* platformData = &(currentFont->platformData());
   HarfBuzzFace* face = platformData->harfBuzzFace();
   if (!face) {
     DLOG(ERROR) << "Could not create HarfBuzzFace from FontPlatformData.";
     return false;
   }
 
   hb_buffer_set_language(harfBuzzBuffer, language);
   hb_buffer_set_script(harfBuzzBuffer, ICUScriptToHBScript(currentRunScript));
-  hb_buffer_set_direction(
-      harfBuzzBuffer,
-      TextDirectionToHBDirection(m_textRun.direction(),
-                                 font->getFontDescription().orientation(),
-                                 currentFont));
+  hb_buffer_set_direction(harfBuzzBuffer, direction);
 
   hb_font_t* hbFont = face->getScaledFont(std::move(currentFontRangeSet));
-  hb_shape(hbFont, harfBuzzBuffer,
-           fontFeatures.isEmpty() ? 0 : fontFeatures.data(),
-           fontFeatures.size());
+  hb_shape(hbFont, harfBuzzBuffer, fontFeatures, fontFeaturesSize);
 
   return true;
 }
 
+}  // namespace
+
 bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
                                          ShapeResult* shapeResult,
                                          bool& fontCycleQueued,
                                          Deque<HolesQueueItem>* holesQueue,
                                          const HolesQueueItem& currentQueueItem,
                                          const Font* font,
                                          const SimpleFontData* currentFont,
                                          UScriptCode currentRunScript,
-                                         bool isLastResort) {
+                                         bool isLastResort) const {
   enum ClusterResult { Shaped, NotDef, Unknown };
   ClusterResult currentClusterResult = Unknown;
   ClusterResult previousClusterResult = Unknown;
   unsigned previousCluster = 0;
   unsigned currentCluster = 0;
 
   // Find first notdef glyph in harfBuzzBuffer.
   unsigned numGlyphs = hb_buffer_get_length(harfBuzzBuffer);
   hb_glyph_info_t* glyphInfo = hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
 
@@ skipping 123 matching lines @@
   if (runOrientation == FontOrientation::VerticalRotated ||
       (runOrientation == FontOrientation::VerticalMixed &&
        renderOrientation == OrientationIterator::OrientationRotateSideways))
     return originalFont->verticalRightOrientationFontData().get();
 
   return originalFont;
 }
 
 bool HarfBuzzShaper::collectFallbackHintChars(
     const Deque<HolesQueueItem>& holesQueue,
-    Vector<UChar32>& hint) {
+    Vector<UChar32>& hint) const {
   if (!holesQueue.size())
     return false;
 
   hint.clear();
 
   size_t numCharsAdded = 0;
   for (auto it = holesQueue.begin(); it != holesQueue.end(); ++it) {
     if (it->m_action == HolesQueueNextFont)
       break;
 
@@ skipping 39 matching lines @@
 
 hb_feature_t createFeature(uint8_t c1,
                            uint8_t c2,
                            uint8_t c3,
                            uint8_t c4,
                            uint32_t value = 0) {
   return {HB_TAG(c1, c2, c3, c4), value, 0 /* start */,
           static_cast<unsigned>(-1) /* end */};
 }
 
-void setFontFeatures(const Font* font,
-                     HarfBuzzShaper::FeaturesVector* features) {
+void setFontFeatures(const Font* font, FeaturesVector* features) {
   const FontDescription& description = font->getFontDescription();
 
   static hb_feature_t noKern = createFeature('k', 'e', 'r', 'n');
   static hb_feature_t noVkrn = createFeature('v', 'k', 'r', 'n');
   switch (description.getKerning()) {
     case FontDescription::NormalKerning:
       // kern/vkrn are enabled by default
       break;
     case FontDescription::NoneKerning:
       features->append(description.isVerticalAnyUpright() ? noVkrn : noKern);
@@ skipping 120 matching lines @@
     feature.start = 0;
     feature.end = static_cast<unsigned>(-1);
     features->append(feature);
   }
 }
 
 class CapsFeatureSettingsScopedOverlay final {
   STACK_ALLOCATED()
 
  public:
-  CapsFeatureSettingsScopedOverlay(HarfBuzzShaper::FeaturesVector*,
+  CapsFeatureSettingsScopedOverlay(FeaturesVector*,
                                    FontDescription::FontVariantCaps);
   CapsFeatureSettingsScopedOverlay() = delete;
   ~CapsFeatureSettingsScopedOverlay();
 
  private:
   void overlayCapsFeatures(FontDescription::FontVariantCaps);
   void prependCounting(const hb_feature_t&);
-  HarfBuzzShaper::FeaturesVector* m_features;
+  FeaturesVector* m_features;
   size_t m_countFeatures;
 };
 
 CapsFeatureSettingsScopedOverlay::CapsFeatureSettingsScopedOverlay(
-    HarfBuzzShaper::FeaturesVector* features,
+    FeaturesVector* features,
     FontDescription::FontVariantCaps variantCaps)
     : m_features(features), m_countFeatures(0) {
   overlayCapsFeatures(variantCaps);
 }
 
 void CapsFeatureSettingsScopedOverlay::overlayCapsFeatures(
     FontDescription::FontVariantCaps variantCaps) {
   static hb_feature_t smcp = createFeature('s', 'm', 'c', 'p', 1);
   static hb_feature_t pcap = createFeature('p', 'c', 'a', 'p', 1);
   static hb_feature_t c2sc = createFeature('c', '2', 's', 'c', 1);
@@ skipping 27 matching lines @@
   m_features->prepend(feature);
   m_countFeatures++;
 }
 
 CapsFeatureSettingsScopedOverlay::~CapsFeatureSettingsScopedOverlay() {
   m_features->remove(0, m_countFeatures);
 }
 
 }  // namespace
 
-PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult(const Font* font) {
+PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult(const Font* font) const {
   RefPtr<ShapeResult> result = ShapeResult::create(
       font, m_normalizedBufferLength, m_textRun.direction());
   HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(),
                                                 hb_buffer_destroy);
   FeaturesVector fontFeatures;
   setFontFeatures(font, &fontFeatures);
   const FontDescription& fontDescription = font->getFontDescription();
   const hb_language_t language =
       fontDescription.localeOrDefault().harfbuzzLanguage();
 
   bool needsCapsHandling =
       fontDescription.variantCaps() != FontDescription::CapsNormal;
   OpenTypeCapsSupport capsSupport;
+  FontOrientation orientation = font->getFontDescription().orientation();
 
   RunSegmenter::RunSegmenterRange segmentRange = {
       0, 0, USCRIPT_INVALID_CODE, OrientationIterator::OrientationInvalid,
       FontFallbackPriority::Invalid};
   RunSegmenter runSegmenter(m_normalizedBuffer.get(), m_normalizedBufferLength,
-                            font->getFontDescription().orientation());
+                            orientation);
 
   Vector<UChar32> fallbackCharsHint;
 
   // TODO: Check whether this treatAsZerowidthspace from the previous script
   // segmentation plays a role here, does the new scriptRuniterator handle that
   // correctly?
   Deque<HolesQueueItem> holesQueue;
   while (runSegmenter.consume(&segmentRange)) {
     RefPtr<FontFallbackIterator> fallbackIterator =
         font->createFontFallbackIterator(segmentRange.fontFallbackPriority);
@@ skipping 16 matching lines @@
         // define a new API on the shaper which will give us coverage
         // information?
         if (!collectFallbackHintChars(holesQueue, fallbackCharsHint)) {
           // Give up shaping since we cannot retrieve a font fallback
           // font without a hintlist.
           holesQueue.clear();
           break;
         }
 
         currentFontDataForRangeSet = fallbackIterator->next(fallbackCharsHint);
-
         if (!currentFontDataForRangeSet->fontData()) {
           DCHECK(!holesQueue.size());
           break;
         }
         fontCycleQueued = false;
         continue;
       }
 
+      const SimpleFontData* fontData = currentFontDataForRangeSet->fontData();
       SmallCapsIterator::SmallCapsBehavior smallCapsBehavior =
           SmallCapsIterator::SmallCapsSameCase;
       if (needsCapsHandling) {
         capsSupport =
-            OpenTypeCapsSupport(currentFontDataForRangeSet->fontData()
-                                    ->platformData()
-                                    .harfBuzzFace(),
+            OpenTypeCapsSupport(fontData->platformData().harfBuzzFace(),
                                 fontDescription.variantCaps(),
                                 ICUScriptToHBScript(segmentRange.script));
         if (capsSupport.needsRunCaseSplitting()) {
           splitUntilNextCaseChange(m_normalizedBuffer.get(), &holesQueue,
                                    currentQueueItem, smallCapsBehavior);
         }
       }
 
       ASSERT(currentQueueItem.m_numCharacters);
 
       const SimpleFontData* smallcapsAdjustedFont =
           needsCapsHandling && capsSupport.needsSyntheticFont(smallCapsBehavior)
-              ? currentFontDataForRangeSet->fontData()
-                    ->smallCapsFontData(fontDescription)
-                    .get()
-              : currentFontDataForRangeSet->fontData();
+              ? fontData->smallCapsFontData(fontDescription).get()
+              : fontData;
 
       // Compatibility with SimpleFontData approach of keeping a flag for
       // overriding drawing direction.
       // TODO: crbug.com/506224 This should go away in favor of storing that
       // information elsewhere, for example in ShapeResult.
       const SimpleFontData* directionAndSmallCapsAdjustedFont =
-          fontDataAdjustedForOrientation(
-              smallcapsAdjustedFont, font->getFontDescription().orientation(),
-              segmentRange.renderOrientation);
+          fontDataAdjustedForOrientation(smallcapsAdjustedFont, orientation,
+                                         segmentRange.renderOrientation);
 
       CaseMapIntend caseMapIntend = CaseMapIntend::KeepSameCase;
-      if (needsCapsHandling) {
+      if (needsCapsHandling)
         caseMapIntend = capsSupport.needsCaseChange(smallCapsBehavior);
-      }
 
       CaseMappingHarfBuzzBufferFiller(
           caseMapIntend, fontDescription.localeOrDefault(),
           harfBuzzBuffer.get(), m_normalizedBuffer.get(),
           m_normalizedBufferLength, currentQueueItem.m_startIndex,
           currentQueueItem.m_numCharacters);
 
       CapsFeatureSettingsScopedOverlay capsOverlay(
           &fontFeatures, capsSupport.fontFeatureToUse(smallCapsBehavior));
 
-      if (!shapeRange(harfBuzzBuffer.get(), font, fontFeatures,
-                      directionAndSmallCapsAdjustedFont,
+      hb_direction_t direction =
+          TextDirectionToHBDirection(m_textRun.direction(), orientation,
+                                     directionAndSmallCapsAdjustedFont);
+
+      if (!shapeRange(harfBuzzBuffer.get(),
+                      fontFeatures.isEmpty() ? 0 : fontFeatures.data(),
+                      fontFeatures.size(), directionAndSmallCapsAdjustedFont,
                       currentFontDataForRangeSet->ranges(), segmentRange.script,
-                      language))
+                      direction, language))
         DLOG(ERROR) << "Shaping range failed.";
 
       if (!extractShapeResults(
               harfBuzzBuffer.get(), result.get(), fontCycleQueued, &holesQueue,
               currentQueueItem, font, directionAndSmallCapsAdjustedFont,
               segmentRange.script, !fallbackIterator->hasNext()))
         DLOG(ERROR) << "Shape result extraction failed.";
 
       hb_buffer_reset(harfBuzzBuffer.get());
     }
   }
   return result.release();
 }
 
 }  // namespace blink