[LayoutNG] Add NG-specific DrawText support to GraphicsContext

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/shaping/ShapeResultBloberizer.h"
 
 #include <hb.h>
 #include "platform/fonts/Font.h"
 #include "platform/fonts/shaping/CachingWordShaper.h"
 #include "platform/fonts/shaping/ShapeResult.h"
@@ skipping 129 matching lines @@
   float advance = 0;
   unsigned word_offset = run_info.run.Rtl() ? run_info.run.length() : 0;
   auto results = result_buffer.results_;
 
   for (unsigned j = 0; j < results.size(); j++) {
     unsigned resolved_index = run_info.run.Rtl() ? results.size() - 1 - j : j;
     const RefPtr<const ShapeResult>& word_result = results[resolved_index];
     for (unsigned i = 0; i < word_result->runs_.size(); i++) {
       unsigned resolved_offset =
           word_offset - (run_info.run.Rtl() ? word_result->NumCharacters() : 0);
-      advance +=
-          FillTextEmphasisGlyphsForRun(word_result->runs_[i].get(), run_info,
-                                       emphasis_data, advance, resolved_offset);
+      advance += FillTextEmphasisGlyphsForRun(
+          word_result->runs_[i].get(), run_info.run,
+          run_info.run.CharactersLength(), run_info.run.Direction(),
+          run_info.from, run_info.to, emphasis_data, advance, resolved_offset);
     }
     word_offset += word_result->NumCharacters() * (run_info.run.Rtl() ? -1 : 1);
   }
 }
 
+void ShapeResultBloberizer::FillTextEmphasisGlyphs(const StringView& text,
+                                                   TextDirection direction,
+                                                   unsigned from,
+                                                   unsigned to,
+                                                   const GlyphData& emphasis,
+                                                   const ShapeResult* result) {
+  float advance = 0;
+  unsigned offset = 0;
+
+  for (unsigned i = 0; i < result->runs_.size(); i++) {
+    advance += FillTextEmphasisGlyphsForRun(result->runs_[i].get(), text,
+                                            text.length(), direction, from, to,
+                                            emphasis, advance, offset);
+  }
+}
+
 namespace {
 
 template <typename TextContainerType>
 inline bool IsSkipInkException(const ShapeResultBloberizer& bloberizer,
                                const TextContainerType& text,
                                unsigned character_index) {
   // We want to skip descenders in general, but it is undesirable renderings for
   // CJK characters.
   return bloberizer.GetType() == ShapeResultBloberizer::Type::kTextIntercepts &&
          !text.Is8Bit() &&
@@ skipping 132 matching lines @@
                             DCHECK(!glyph_data.offset.Height());
                             Add(glyph_data.glyph, run->font_data_.Get(),
                                 total_advance + glyph_data.offset.Width());
                             return true;
                           });
   }
 
   return advance;
 }
 
+template <typename TextContainerType>
 float ShapeResultBloberizer::FillTextEmphasisGlyphsForRun(
     const ShapeResult::RunInfo* run,
-    const TextRunPaintInfo& run_info,
+    const TextContainerType& text,
+    unsigned text_length,
+    TextDirection direction,
+    unsigned from,
+    unsigned to,
     const GlyphData& emphasis_data,
     float initial_advance,
     unsigned run_offset) {
   if (!run)
     return 0;
 
   unsigned graphemes_in_cluster = 1;
   float cluster_advance = 0;
 
   FloatPoint glyph_center =
       emphasis_data.font_data->BoundsForGlyph(emphasis_data.glyph).Center();
 
-  const auto& text_run = run_info.run;
-  const auto from = run_info.from;
-  const auto to = run_info.to;
-
-  TextDirection direction = text_run.Direction();
-
   // A "cluster" in this context means a cluster as it is used by HarfBuzz:
   // The minimal group of characters and corresponding glyphs, that cannot be
   // broken down further from a text shaping point of view.  A cluster can
   // contain multiple glyphs and grapheme clusters, with mutually overlapping
   // boundaries. Below we count grapheme clusters per HarfBuzz clusters, then
   // linearly split the sum of corresponding glyph advances by the number of
   // grapheme clusters in order to find positions for emphasis mark drawing.
   uint16_t cluster_start = static_cast<uint16_t>(
       direction == TextDirection::kRtl
           ? run->start_index_ + run->num_characters_ + run_offset
@@ skipping 12 matching lines @@
 
     if ((direction == TextDirection::kRtl && current_character_index >= to) ||
         (direction != TextDirection::kRtl && current_character_index < from)) {
       advance_so_far += glyph_data.advance;
       direction == TextDirection::kRtl ? --cluster_start : ++cluster_start;
       continue;
     }
 
     cluster_advance += glyph_data.advance;
 
-    if (text_run.Is8Bit()) {
+    if (text.Is8Bit()) {
       float glyph_advance_x = glyph_data.advance;
-      if (Character::CanReceiveTextEmphasis(
-              text_run[current_character_index])) {
+      if (Character::CanReceiveTextEmphasis(text[current_character_index])) {
         AddEmphasisMark(*this, emphasis_data, glyph_center,
                         advance_so_far + glyph_advance_x / 2);
       }
       advance_so_far += glyph_advance_x;
     } else if (is_cluster_end) {
       uint16_t cluster_end;
       if (direction == TextDirection::kRtl) {
         cluster_end = current_character_index;
       } else {
         cluster_end = static_cast<uint16_t>(
             is_run_end ? run->start_index_ + run->num_characters_ + run_offset
                        : run->GlyphToCharacterIndex(i + 1) + run_offset);
       }
       graphemes_in_cluster = CountGraphemesInCluster(
-          text_run.Characters16(), text_run.CharactersLength(), cluster_start,
-          cluster_end);
+          text.Characters16(), text_length, cluster_start, cluster_end);
       if (!graphemes_in_cluster || !cluster_advance)
         continue;
 
       float glyph_advance_x = cluster_advance / graphemes_in_cluster;
       for (unsigned j = 0; j < graphemes_in_cluster; ++j) {
         // Do not put emphasis marks on space, separator, and control
         // characters.
-        if (Character::CanReceiveTextEmphasis(
-                text_run[current_character_index])) {
+        if (Character::CanReceiveTextEmphasis(text[current_character_index])) {
           AddEmphasisMark(*this, emphasis_data, glyph_center,
                           advance_so_far + glyph_advance_x / 2);
         }
         advance_so_far += glyph_advance_x;
       }
       cluster_start = cluster_end;
       cluster_advance = 0;
     }
   }
   return advance_so_far - initial_advance;
 }
 
 }  // namespace blink