Refactor InspectorCSSAgent to avoid an intermediate GlyphBuffer

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 91 matching lines @@
   // rectified by using RefPtrs for Fonts themselves.
   if (!m_fontFallbackList)
     m_fontFallbackList = FontFallbackList::create();
   m_fontFallbackList->invalidate(fontSelector);
 }
 
 float Font::buildGlyphBuffer(const TextRunPaintInfo& runInfo,
                              GlyphBuffer& glyphBuffer,
                              const GlyphData* emphasisData) const {
   float width;
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
+  CachingWordShaper shaper(*this);
   if (emphasisData) {
-    width = shaper.fillGlyphBufferForTextEmphasis(this, runInfo.run,
+    width = shaper.fillGlyphBufferForTextEmphasis(runInfo.run,
                                                   emphasisData, &glyphBuffer,
                                                   runInfo.from, runInfo.to);
   } else {
-    width = shaper.fillGlyphBuffer(this, runInfo.run, nullptr, &glyphBuffer,
+    width = shaper.fillGlyphBuffer(runInfo.run, &glyphBuffer,
                                    runInfo.from, runInfo.to);
   }
   return width;
 }
 
 bool Font::drawText(PaintCanvas* canvas,
                     const TextRunPaintInfo& runInfo,
                     const FloatPoint& point,
                     float deviceScaleFactor,
                     const PaintFlags& flags) const {
@@ skipping 88 matching lines @@
   if (glyphBuffer.isEmpty())
     return;
 
   drawGlyphBuffer(canvas, flags, glyphBuffer, point, deviceScaleFactor);
 }
 
 float Font::width(const TextRun& run,
                   HashSet<const SimpleFontData*>* fallbackFonts,
                   FloatRect* glyphBounds) const {
   FontCachePurgePreventer purgePreventer;
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
-  float width = shaper.width(this, run, fallbackFonts, glyphBounds);
-  return width;
+  CachingWordShaper shaper(*this);
+  return shaper.width(run, fallbackFonts, glyphBounds);
 }
 
 namespace {
 
 enum BlobRotation {
   NoRotation,
   CCWRotation,
 };
 
 class GlyphBufferBloberizer {
@@ skipping 191 matching lines @@
                                      int to,
                                      bool accountForGlyphBounds) const {
   to = (to == -1 ? run.length() : to);
 
   TextRunPaintInfo runInfo(run);
   runInfo.from = from;
   runInfo.to = to;
 
   FontCachePurgePreventer purgePreventer;
 
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
-  CharacterRange range = shaper.getCharacterRange(this, run, from, to);
+  CachingWordShaper shaper(*this);
+  CharacterRange range = shaper.getCharacterRange(run, from, to);
 
   return pixelSnappedSelectionRect(
       FloatRect(point.x() + range.start, point.y(), range.width(), height));
 }
 
 int Font::offsetForPosition(const TextRun& run,
                             float xFloat,
                             bool includePartialGlyphs) const {
   FontCachePurgePreventer purgePreventer;
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
-  return shaper.offsetForPosition(this, run, xFloat, includePartialGlyphs);
+  CachingWordShaper shaper(*this);
+  return shaper.offsetForPosition(run, xFloat, includePartialGlyphs);
 }
 
 ShapeCache* Font::shapeCache() const {
   return m_fontFallbackList->shapeCache(m_fontDescription);
 }
 
 bool Font::canShapeWordByWord() const {
   if (!m_shapeWordByWordComputed) {
     m_canShapeWordByWord = computeCanShapeWordByWord();
     m_shapeWordByWordComputed = true;
@@ skipping 90 matching lines @@
   if (!markFontData)
     return 0;
 
   return markFontData->getFontMetrics().height();
 }
 
 CharacterRange Font::getCharacterRange(const TextRun& run,
                                        unsigned from,
                                        unsigned to) const {
   FontCachePurgePreventer purgePreventer;
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
-  return shaper.getCharacterRange(this, run, from, to);
+  CachingWordShaper shaper(*this);
+  return shaper.getCharacterRange(run, from, to);
 }
 
 Vector<CharacterRange> Font::individualCharacterRanges(
     const TextRun& run) const {
   FontCachePurgePreventer purgePreventer;
-  CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
-  auto ranges = shaper.individualCharacterRanges(this, run);
+  CachingWordShaper shaper(*this);
+  auto ranges = shaper.individualCharacterRanges(run);
   // The shaper should return ranges.size == run.length but on some platforms
   // (OSX10.9.5) we are seeing cases in the upper end of the unicode range
   // where this is not true (see: crbug.com/620952). To catch these cases on
   // more popular platforms, and to protect users, we are using a CHECK here.
   CHECK_EQ(ranges.size(), run.length());
   return ranges;
 }
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink