Add support for shaping a substring to 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 22 matching lines @@
 
 #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/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>;
 
+enum HolesQueueItemAction { HolesQueueNextFont, HolesQueueRange };
+
+struct HolesQueueItem {
+  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+  HolesQueueItemAction m_action;
+  unsigned m_startIndex;
+  unsigned m_numCharacters;
+  HolesQueueItem(HolesQueueItemAction action, unsigned start, unsigned num)
+      : m_action(action), m_startIndex(start), m_numCharacters(num){};
+};
+
 template <typename T>
 class HarfBuzzScopedPtr {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(HarfBuzzScopedPtr);
 
  public:
   typedef void (*DestroyFunction)(T*);
 
   HarfBuzzScopedPtr(T* ptr, DestroyFunction destroy)
       : m_ptr(ptr), m_destroy(destroy) {
     ASSERT(m_destroy);
   }
   ~HarfBuzzScopedPtr() {
     if (m_ptr)
       (*m_destroy)(m_ptr);
   }
 
   T* get() { return m_ptr; }
   void set(T* ptr) { m_ptr = ptr; }
 
  private:
   T* m_ptr;
   DestroyFunction m_destroy;
 };
 
 HarfBuzzShaper::HarfBuzzShaper(const UChar* text,
                                unsigned length,
                                TextDirection direction)
-    : m_normalizedBuffer(text),
-      m_normalizedBufferLength(length),
-      m_textDirection(direction) {}
+    : m_text(text), m_textLength(length), m_paragraphDirection(direction) {}
 
 namespace {
 
 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built
 // without hb-icu. See http://crbug.com/356929
 static inline hb_script_t ICUScriptToHBScript(UScriptCode script) {
   if (UNLIKELY(script == USCRIPT_INVALID_CODE))
     return HB_SCRIPT_INVALID;
 
   return hb_script_from_string(uscript_getShortName(script), -1);
 }
 
 static inline hb_direction_t TextDirectionToHBDirection(
     TextDirection dir,
     FontOrientation orientation,
     const SimpleFontData* fontData) {
   hb_direction_t harfBuzzDirection =
       isVerticalAnyUpright(orientation) &&
               !fontData->isTextOrientationFallback()
           ? HB_DIRECTION_TTB
           : HB_DIRECTION_LTR;
   return dir == TextDirection::kRtl ? HB_DIRECTION_REVERSE(harfBuzzDirection)
                                     : harfBuzzDirection;
 }
 
-inline bool shapeRange(hb_buffer_t* harfBuzzBuffer,
+inline bool shapeRange(hb_buffer_t* buffer,
                        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, direction);
+  hb_buffer_set_language(buffer, language);
+  hb_buffer_set_script(buffer, ICUScriptToHBScript(currentRunScript));
+  hb_buffer_set_direction(buffer, direction);
 
   hb_font_t* hbFont = face->getScaledFont(std::move(currentFontRangeSet));
-  hb_shape(hbFont, harfBuzzBuffer, fontFeatures, fontFeaturesSize);
+  hb_shape(hbFont, buffer, fontFeatures, fontFeaturesSize);
 
   return true;
 }
 
 }  // namespace
 
-bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
+bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* buffer,
                                          ShapeResult* shapeResult,
                                          bool& fontCycleQueued,
                                          Deque<HolesQueueItem>* holesQueue,
                                          const HolesQueueItem& currentQueueItem,
                                          const Font* font,
                                          const SimpleFontData* currentFont,
                                          UScriptCode currentRunScript,
                                          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);
+  // Find first notdef glyph in buffer.
+  unsigned numGlyphs = hb_buffer_get_length(buffer);
+  hb_glyph_info_t* glyphInfo = hb_buffer_get_glyph_infos(buffer, 0);
 
   unsigned lastChangePosition = 0;
 
   if (!numGlyphs) {
     DLOG(ERROR) << "HarfBuzz returned empty glyph buffer after shaping.";
     return false;
   }
 
   for (unsigned glyphIndex = 0; glyphIndex <= numGlyphs; ++glyphIndex) {
     // Iterating by clusters, check for when the state switches from shaped
@@ skipping 35 matching lines @@
                     previousClusterResult != Unknown;
     if (!atChange)
       continue;
 
     // Compute the range indices of consecutive shaped or .notdef glyphs.
     // Cluster information for RTL runs becomes reversed, e.g. character 0
     // has cluster index 5 in a run of 6 characters.
     unsigned numCharacters = 0;
     unsigned numGlyphsToInsert = 0;
     unsigned startIndex = 0;
-    if (HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harfBuzzBuffer))) {
+    if (HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(buffer))) {
       startIndex = glyphInfo[lastChangePosition].cluster;
       if (glyphIndex == numGlyphs) {
         numCharacters = currentQueueItem.m_startIndex +
                         currentQueueItem.m_numCharacters -
                         glyphInfo[lastChangePosition].cluster;
         numGlyphsToInsert = numGlyphs - lastChangePosition;
       } else {
         numCharacters = glyphInfo[glyphIndex].cluster -
                         glyphInfo[lastChangePosition].cluster;
         numGlyphsToInsert = glyphIndex - lastChangePosition;
@@ skipping 27 matching lines @@
 
     // If numCharacters is 0, that means we hit a NotDef before shaping the
     // whole grapheme. We do not append it here. For the next glyph we
     // encounter, atChange will be true, and the characters corresponding to
     // the grapheme will be added to the TODO queue again, attempting to
     // shape the whole grapheme with the next font.
     // When we're getting here with the last resort font, we have no other
     // choice than adding boxes to the ShapeResult.
     if ((currentClusterResult == NotDef && numCharacters) || isLastResort) {
       hb_direction_t direction = TextDirectionToHBDirection(
-          m_textDirection, font->getFontDescription().orientation(),
+          m_paragraphDirection, font->getFontDescription().orientation(),
           currentFont);
       // Here we need to specify glyph positions.
       ShapeResult::RunInfo* run = new ShapeResult::RunInfo(
           currentFont, direction, ICUScriptToHBScript(currentRunScript),
           startIndex, numGlyphsToInsert, numCharacters);
       shapeResult->insertRun(WTF::wrapUnique(run), lastChangePosition,
-                             numGlyphsToInsert, harfBuzzBuffer);
+                             numGlyphsToInsert, buffer);
     }
     lastChangePosition = glyphIndex;
   }
   return true;
 }
 
 static inline const SimpleFontData* fontDataAdjustedForOrientation(
     const SimpleFontData* originalFont,
     FontOrientation runOrientation,
     OrientationIterator::RenderOrientation renderOrientation) {
   if (!isVerticalBaseline(runOrientation))
     return originalFont;
 
   if (runOrientation == FontOrientation::VerticalRotated ||
       (runOrientation == FontOrientation::VerticalMixed &&
        renderOrientation == OrientationIterator::OrientationRotateSideways))
     return originalFont->verticalRightOrientationFontData().get();
 
   return originalFont;
 }
 
 bool HarfBuzzShaper::collectFallbackHintChars(
-    const Deque<HolesQueueItem>& holesQueue,
+    const Deque<HolesQueueItem>* holesQueue,
     Vector<UChar32>& hint) const {
-  if (!holesQueue.size())
+  DCHECK(holesQueue);
+  if (!holesQueue->size())
     return false;
 
   hint.clear();
 
   size_t numCharsAdded = 0;
-  for (auto it = holesQueue.begin(); it != holesQueue.end(); ++it) {
+  for (auto it = holesQueue->begin(); it != holesQueue->end(); ++it) {
     if (it->m_action == HolesQueueNextFont)
       break;
 
     UChar32 hintChar;
-    RELEASE_ASSERT(it->m_startIndex + it->m_numCharacters <=
-                   m_normalizedBufferLength);
-    UTF16TextIterator iterator(m_normalizedBuffer + it->m_startIndex,
-                               it->m_numCharacters);
+    RELEASE_ASSERT(it->m_startIndex + it->m_numCharacters <= m_textLength);
+    UTF16TextIterator iterator(m_text + it->m_startIndex, it->m_numCharacters);
     while (iterator.consume(hintChar)) {
       hint.push_back(hintChar);
       numCharsAdded++;
       iterator.advance();
     }
   }
   return numCharsAdded > 0;
 }
 
 namespace {
-using HolesQueueItem = HarfBuzzShaper::HolesQueueItem;
-using HolesQueueItemAction = HarfBuzzShaper::HolesQueueItemAction;
 
 void splitUntilNextCaseChange(
     const UChar* normalizedBuffer,
-    Deque<HolesQueueItem>* queue,
-    HolesQueueItem& currentQueueItem,
+    Deque<blink::HolesQueueItem>* queue,
+    blink::HolesQueueItem& currentQueueItem,
     SmallCapsIterator::SmallCapsBehavior& smallCapsBehavior) {
   unsigned numCharactersUntilCaseChange = 0;
   SmallCapsIterator smallCapsIterator(
       normalizedBuffer + currentQueueItem.m_startIndex,
       currentQueueItem.m_numCharacters);
   smallCapsIterator.consume(&numCharactersUntilCaseChange, &smallCapsBehavior);
   if (numCharactersUntilCaseChange > 0 &&
       numCharactersUntilCaseChange < currentQueueItem.m_numCharacters) {
-    queue->prepend(HolesQueueItem(
-        HolesQueueItemAction::HolesQueueRange,
+    queue->prepend(blink::HolesQueueItem(
+        blink::HolesQueueItemAction::HolesQueueRange,
         currentQueueItem.m_startIndex + numCharactersUntilCaseChange,
         currentQueueItem.m_numCharacters - numCharactersUntilCaseChange));
     currentQueueItem.m_numCharacters = numCharactersUntilCaseChange;
   }
 }
 
 hb_feature_t createFeature(hb_tag_t tag, uint32_t value = 0) {
   return {tag, value, 0 /* start */, static_cast<unsigned>(-1) /* end */};
 }
 
@@ skipping 192 matching lines @@
   m_features->prepend(feature);
   m_countFeatures++;
 }
 
 CapsFeatureSettingsScopedOverlay::~CapsFeatureSettingsScopedOverlay() {
   m_features->remove(0, m_countFeatures);
 }
 
 }  // namespace
 
-PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult(const Font* font) const {
-  RefPtr<ShapeResult> result =
-      ShapeResult::create(font, m_normalizedBufferLength, m_textDirection);
-  HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(),
-                                                hb_buffer_destroy);
-  FeaturesVector fontFeatures;
-  setFontFeatures(font, &fontFeatures);
+void HarfBuzzShaper::shapeSegment(ShapeResult* result,
+                                  Deque<HolesQueueItem>* holesQueue,
+                                  hb_buffer_t* buffer,
+                                  const Font* font,
+                                  FeaturesVector* fontFeatures,
+                                  RunSegmenter::RunSegmenterRange segment,
+                                  unsigned start,
+                                  unsigned end) const {
+  DCHECK(result);
+  DCHECK(holesQueue);
+  DCHECK(buffer);
+
   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();
+  RefPtr<FontFallbackIterator> fallbackIterator =
+      font->createFontFallbackIterator(segment.fontFallbackPriority);
+
+  holesQueue->append(HolesQueueItem(HolesQueueNextFont, 0, 0));
+  holesQueue->append(HolesQueueItem(HolesQueueRange, segment.start,
+                                    segment.end - segment.start));
+
+  bool fontCycleQueued = false;
+  Vector<UChar32> fallbackCharsHint;
+  RefPtr<FontDataForRangeSet> currentFontDataForRangeSet;
+  while (holesQueue->size()) {
+    HolesQueueItem currentQueueItem = holesQueue->takeFirst();
+
+    if (currentQueueItem.m_action == HolesQueueNextFont) {
+      // For now, we're building a character list with which we probe
+      // for needed fonts depending on the declared unicode-range of a
+      // segmented CSS font. Alternatively, we can build a fake font
+      // for the shaper and check whether any glyphs were found, or
+      // 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(fontData->platformData().harfBuzzFace(),
+                                        fontDescription.variantCaps(),
+                                        ICUScriptToHBScript(segment.script));
+      if (capsSupport.needsRunCaseSplitting()) {
+        splitUntilNextCaseChange(m_text, holesQueue, currentQueueItem,
+                                 smallCapsBehavior);
+      }
+    }
+
+    DCHECK(currentQueueItem.m_numCharacters);
+    const SimpleFontData* smallcapsAdjustedFont =
+        needsCapsHandling && capsSupport.needsSyntheticFont(smallCapsBehavior)
+            ? 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, orientation,
+                                       segment.renderOrientation);
+
+    CaseMapIntend caseMapIntend = CaseMapIntend::KeepSameCase;
+    if (needsCapsHandling)
+      caseMapIntend = capsSupport.needsCaseChange(smallCapsBehavior);
+
+    // Clamp the start and end offsets of the queue item to the offsets

[drott, 2017/02/08 15:52:59]

What do you anticipate these shapeStart and shapeEnd values to be? It might be
difficult to choose these correctly, without something like a safe-to-break API
that we discussed with Behdad before. If index values for shapeStart and
shapeEnd are used which point to the middle of a 3-character cluster for
example, the result may become an unshaped .notdef at the beginning of the
string, whereas if the whole cluster is contained within start and end it would
work out.

+    // representing the shaping window.
+    unsigned shapeStart = std::max(start, currentQueueItem.m_startIndex);
+    unsigned shapeEnd = std::min(
+        end, currentQueueItem.m_startIndex + currentQueueItem.m_numCharacters);
+
+    CaseMappingHarfBuzzBufferFiller(
+        caseMapIntend, fontDescription.localeOrDefault(), buffer, m_text,
+        m_textLength, shapeStart, shapeEnd - shapeStart);
+
+    CapsFeatureSettingsScopedOverlay capsOverlay(
+        fontFeatures, capsSupport.fontFeatureToUse(smallCapsBehavior));
+    hb_direction_t direction = TextDirectionToHBDirection(
+        m_paragraphDirection, orientation, directionAndSmallCapsAdjustedFont);
+
+    if (!shapeRange(buffer, fontFeatures->isEmpty() ? 0 : fontFeatures->data(),
+                    fontFeatures->size(), directionAndSmallCapsAdjustedFont,
+                    currentFontDataForRangeSet->ranges(), segment.script,
+                    direction, language))
+      DLOG(ERROR) << "Shaping range failed.";
+
+    if (!extractShapeResults(buffer, result, fontCycleQueued, holesQueue,
+                             currentQueueItem, font,
+                             directionAndSmallCapsAdjustedFont, segment.script,
+                             !fallbackIterator->hasNext()))
+      DLOG(ERROR) << "Shape result extraction failed.";
+
+    hb_buffer_reset(buffer);
+  }
+}
+
+PassRefPtr<ShapeResult> HarfBuzzShaper::shape(const Font* font,
+                                              unsigned start,
+                                              unsigned end) const {
+  DCHECK(end >= start);
+  DCHECK(end <= m_textLength);
+
+  unsigned length = end - start;
+  RefPtr<ShapeResult> result =
+      ShapeResult::create(font, length, m_paragraphDirection);
+  HarfBuzzScopedPtr<hb_buffer_t> buffer(hb_buffer_create(), hb_buffer_destroy);
+
+  FeaturesVector fontFeatures;
+  setFontFeatures(font, &fontFeatures);
   FontOrientation orientation = font->getFontDescription().orientation();
 
-  RunSegmenter::RunSegmenterRange segmentRange = {
-      0, 0, USCRIPT_INVALID_CODE, OrientationIterator::OrientationInvalid,
-      FontFallbackPriority::Invalid};
-  RunSegmenter runSegmenter(m_normalizedBuffer, m_normalizedBufferLength,
-                            orientation);
+  // Run segmentation needs to operate on the entire string, regardless of the
+  // shaping window (defined by the start and end parameters).
+  RunSegmenter::RunSegmenterRange segmentRange = RunSegmenter::nullRange();
+  RunSegmenter runSegmenter(m_text, m_textLength, 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);
-
-    holesQueue.append(HolesQueueItem(HolesQueueNextFont, 0, 0));
-    holesQueue.append(HolesQueueItem(HolesQueueRange, segmentRange.start,
-                                     segmentRange.end - segmentRange.start));
-
-    RefPtr<FontDataForRangeSet> currentFontDataForRangeSet;
-
-    bool fontCycleQueued = false;
-    while (holesQueue.size()) {
-      HolesQueueItem currentQueueItem = holesQueue.takeFirst();
-
-      if (currentQueueItem.m_action == HolesQueueNextFont) {
-        // For now, we're building a character list with which we probe
-        // for needed fonts depending on the declared unicode-range of a
-        // segmented CSS font. Alternatively, we can build a fake font
-        // for the shaper and check whether any glyphs were found, or
-        // 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(fontData->platformData().harfBuzzFace(),
-                                fontDescription.variantCaps(),
-                                ICUScriptToHBScript(segmentRange.script));
-        if (capsSupport.needsRunCaseSplitting()) {
-          splitUntilNextCaseChange(m_normalizedBuffer, &holesQueue,
-                                   currentQueueItem, smallCapsBehavior);
-        }
-      }
-
-      ASSERT(currentQueueItem.m_numCharacters);
-
-      const SimpleFontData* smallcapsAdjustedFont =
-          needsCapsHandling && capsSupport.needsSyntheticFont(smallCapsBehavior)
-              ? 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, orientation,
-                                         segmentRange.renderOrientation);
-
-      CaseMapIntend caseMapIntend = CaseMapIntend::KeepSameCase;
-      if (needsCapsHandling)
-        caseMapIntend = capsSupport.needsCaseChange(smallCapsBehavior);
-
-      CaseMappingHarfBuzzBufferFiller(
-          caseMapIntend, fontDescription.localeOrDefault(),
-          harfBuzzBuffer.get(), m_normalizedBuffer, m_normalizedBufferLength,
-          currentQueueItem.m_startIndex, currentQueueItem.m_numCharacters);
-
-      CapsFeatureSettingsScopedOverlay capsOverlay(
-          &fontFeatures, capsSupport.fontFeatureToUse(smallCapsBehavior));
-
-      hb_direction_t direction = TextDirectionToHBDirection(
-          m_textDirection, orientation, directionAndSmallCapsAdjustedFont);
-
-      if (!shapeRange(harfBuzzBuffer.get(),
-                      fontFeatures.isEmpty() ? 0 : fontFeatures.data(),
-                      fontFeatures.size(), directionAndSmallCapsAdjustedFont,
-                      currentFontDataForRangeSet->ranges(), segmentRange.script,
-                      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());
+    // Only shape segments within the range indicated by start and end offsets.

[drott, 2017/02/08 15:52:59]

IIUC the condition currently means: // Only shape segments overlapping with the
range indicated by start and end. Not only those strictly within. 

Is this what you meant? If yes, could you edit the comment?

+    if (start < segmentRange.end && end > segmentRange.start) {
+      shapeSegment(result.get(), &holesQueue, buffer.get(), font, &fontFeatures,
+                   segmentRange, start, end);
     }
   }
   return result.release();
 }
 
+PassRefPtr<ShapeResult> HarfBuzzShaper::shape(const Font* font) const {
+  return shape(font, 0, m_textLength);
+}
 }  // namespace blink