[LayoutNG] Add Font::GetTextIntercepts for LayoutNG

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 254 matching lines @@
 }
 
 float Font::Width(const TextRun& run,
                   HashSet<const SimpleFontData*>* fallback_fonts,
                   FloatRect* glyph_bounds) const {
   FontCachePurgePreventer purge_preventer;
   CachingWordShaper shaper(*this);
   return shaper.Width(run, fallback_fonts, glyph_bounds);
 }
 
-static int GetInterceptsFromBlobs(
-    const ShapeResultBloberizer::BlobBuffer& blobs,
-    const SkPaint& paint,
-    const std::tuple<float, float>& bounds,
-    SkScalar* intercepts_buffer) {
+namespace {  // anonymous namespace
+
+unsigned InterceptsFromBlobs(const ShapeResultBloberizer::BlobBuffer& blobs,
+                             const SkPaint& paint,
+                             const std::tuple<float, float>& bounds,
+                             SkScalar* intercepts_buffer) {
   SkScalar bounds_array[2] = {std::get<0>(bounds), std::get<1>(bounds)};
 
-  int num_intervals = 0;
+  unsigned num_intervals = 0;
   for (const auto& blob_info : blobs) {
     DCHECK(blob_info.blob);
 
     // ShapeResultBloberizer splits for a new blob rotation, but does not split
     // for a change in font. A TextBlob can contain runs with differing fonts
     // and the getTextBlobIntercepts method handles multiple fonts for us. For
     // upright in vertical blobs we currently have to bail, see crbug.com/655154
     if (blob_info.rotation == ShapeResultBloberizer::BlobRotation::kCCWRotation)
       continue;
 
     SkScalar* offset_intercepts_buffer = nullptr;
     if (intercepts_buffer)
       offset_intercepts_buffer = &intercepts_buffer[num_intervals];
     num_intervals += paint.getTextBlobIntercepts(
         blob_info.blob.get(), bounds_array, offset_intercepts_buffer);
   }
   return num_intervals;
 }
 
+void GetTextInterceptsInternal(const ShapeResultBloberizer::BlobBuffer& blobs,
+                               const PaintFlags& flags,
+                               const std::tuple<float, float>& bounds,
+                               Vector<Font::TextIntercept>& intercepts) {
+  // Get the number of intervals, without copying the actual values by
+  // specifying nullptr for the buffer, following the Skia allocation model for
+  // retrieving text intercepts.
+  SkPaint paint(ToSkPaint(flags));
+  unsigned num_intervals = InterceptsFromBlobs(blobs, paint, bounds, nullptr);
+  if (!num_intervals)
+    return;
+  DCHECK_EQ(num_intervals % 2, 0u);
+  intercepts.resize(num_intervals / 2u);
+
+  InterceptsFromBlobs(blobs, paint, bounds,
+                      reinterpret_cast<SkScalar*>(intercepts.data()));
+}
+
+}  // anonymous namespace
+
 void Font::GetTextIntercepts(const TextRunPaintInfo& run_info,
                              float device_scale_factor,
                              const PaintFlags& flags,
                              const std::tuple<float, float>& bounds,
                              Vector<TextIntercept>& intercepts) const {
   if (ShouldSkipDrawing())
     return;
 
   ShapeResultBloberizer bloberizer(
       *this, device_scale_factor, ShapeResultBloberizer::Type::kTextIntercepts);
-
   CachingWordShaper word_shaper(*this);
   ShapeResultBuffer buffer;
   word_shaper.FillResultBuffer(run_info, &buffer);
   bloberizer.FillGlyphs(run_info, buffer);
 
-  const auto& blobs = bloberizer.Blobs();
+  GetTextInterceptsInternal(bloberizer.Blobs(), flags, bounds, intercepts);
+}
 
-  // Get the number of intervals, without copying the actual values by
-  // specifying nullptr for the buffer, following the Skia allocation model for
-  // retrieving text intercepts.
-  SkPaint paint(ToSkPaint(flags));
-  int num_intervals = GetInterceptsFromBlobs(blobs, paint, bounds, nullptr);
-  if (!num_intervals)
+void Font::GetTextIntercepts(const TextFragmentPaintInfo& text_info,
+                             float device_scale_factor,
+                             const PaintFlags& flags,
+                             const std::tuple<float, float>& bounds,
+                             Vector<TextIntercept>& intercepts) const {
+  if (ShouldSkipDrawing())
     return;
-  DCHECK_EQ(num_intervals % 2, 0);
-  intercepts.resize(num_intervals / 2);
 
-  GetInterceptsFromBlobs(blobs, paint, bounds,
-                         reinterpret_cast<SkScalar*>(intercepts.data()));
+  ShapeResultBloberizer bloberizer(
+      *this, device_scale_factor, ShapeResultBloberizer::Type::kTextIntercepts);
+  bloberizer.FillGlyphs(text_info.text, text_info.from, text_info.to,
+                        text_info.shape_result);
+
+  GetTextInterceptsInternal(bloberizer.Blobs(), flags, bounds, intercepts);
 }
 
 static inline FloatRect PixelSnappedSelectionRect(FloatRect rect) {
   // Using roundf() rather than ceilf() for the right edge as a compromise to
   // ensure correct caret positioning.
   float rounded_x = roundf(rect.X());
   return FloatRect(rounded_x, rect.Y(), roundf(rect.MaxX() - rounded_x),
                    rect.Height());
 }
 
@@ skipping 124 matching lines @@
 
 bool Font::LoadingCustomFonts() const {
   return font_fallback_list_ && font_fallback_list_->LoadingCustomFonts();
 }
 
 bool Font::IsFallbackValid() const {
   return !font_fallback_list_ || font_fallback_list_->IsValid();
 }
 
 }  // namespace blink