Move blobalizer implementation to ShapeResultBloberizer

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 124 matching lines @@
                     const TextRunPaintInfo& run_info,
                     const FloatPoint& point,
                     float device_scale_factor,
                     const PaintFlags& flags) const {
   // Don't draw anything while we are using custom fonts that are in the process
   // of loading.
   if (ShouldSkipDrawing())
     return false;
 
   ShapeResultBloberizer bloberizer(*this, device_scale_factor);
-  CachingWordShaper(*this).FillGlyphs(run_info, bloberizer);
+  CachingWordShaper word_shaper(*this);
+  ShapeResultBuffer buffer;
+  word_shaper.FillResultBuffer(run_info, &buffer);
+  bloberizer.FillGlyphs(run_info, buffer);
   DrawBlobs(canvas, flags, bloberizer.Blobs(), point);
   return true;
 }
 
 bool Font::DrawBidiText(PaintCanvas* canvas,
                         const TextRunPaintInfo& run_info,
                         const FloatPoint& point,
                         CustomFontNotReadyAction custom_font_not_ready_action,
                         float device_scale_factor,
                         const PaintFlags& flags) const {
@@ skipping 15 matching lines @@
 
   // FIXME: This ownership should be reversed. We should pass BidiRunList
   // to BidiResolver in createBidiRunsForLine.
   BidiRunList<BidiCharacterRun>& bidi_runs = bidi_resolver.Runs();
   bidi_resolver.CreateBidiRunsForLine(TextRunIterator(&run, run.length()));
   if (!bidi_runs.RunCount())
     return true;
 
   FloatPoint curr_point = point;
   BidiCharacterRun* bidi_run = bidi_runs.FirstRun();
+  CachingWordShaper word_shaper(*this);
   while (bidi_run) {
     TextRun subrun =
         run.SubRun(bidi_run->Start(), bidi_run->Stop() - bidi_run->Start());
     bool is_rtl = bidi_run->Level() % 2;
     subrun.SetDirection(is_rtl ? TextDirection::kRtl : TextDirection::kLtr);
     subrun.SetDirectionalOverride(bidi_run->DirOverride(false));
 
     TextRunPaintInfo subrun_info(subrun);
     subrun_info.bounds = run_info.bounds;
 
     ShapeResultBloberizer bloberizer(*this, device_scale_factor);
-    float run_width =
-        CachingWordShaper(*this).FillGlyphs(subrun_info, bloberizer);
+    ShapeResultBuffer buffer;
+    word_shaper.FillResultBuffer(subrun_info, &buffer);
+    float run_width = bloberizer.FillGlyphs(subrun_info, buffer);
     DrawBlobs(canvas, flags, bloberizer.Blobs(), curr_point);
 
     bidi_run = bidi_run->Next();
     curr_point.Move(run_width, 0);
   }
 
   bidi_runs.DeleteRuns();
   return true;
 }
 
 void Font::DrawEmphasisMarks(PaintCanvas* canvas,
                              const TextRunPaintInfo& run_info,
                              const AtomicString& mark,
                              const FloatPoint& point,
                              float device_scale_factor,
                              const PaintFlags& flags) const {
   if (ShouldSkipDrawing())
     return;
 
   FontCachePurgePreventer purge_preventer;
 
   const auto emphasis_glyph_data = GetEmphasisMarkGlyphData(mark);
   if (!emphasis_glyph_data.font_data)
     return;
 
   ShapeResultBloberizer bloberizer(*this, device_scale_factor);
-  CachingWordShaper(*this).FillTextEmphasisGlyphs(run_info, emphasis_glyph_data,
-                                                  bloberizer);
+  CachingWordShaper word_shaper(*this);
+  ShapeResultBuffer buffer;
+  word_shaper.FillResultBuffer(run_info, &buffer);
+  bloberizer.FillTextEmphasisGlyphs(run_info, emphasis_glyph_data, buffer);
   DrawBlobs(canvas, flags, bloberizer.Blobs(), point);
 }
 
 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);
 }
@@ skipping 28 matching lines @@
 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(*this).FillGlyphs(run_info, bloberizer);
+
+  CachingWordShaper word_shaper(*this);
+  ShapeResultBuffer buffer;
+  word_shaper.FillResultBuffer(run_info, &buffer);
+  bloberizer.FillGlyphs(run_info, buffer);
+
   const auto& blobs = bloberizer.Blobs();
 
   // 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)
     return;
   DCHECK_EQ(num_intervals % 2, 0);
@@ skipping 138 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