Remove the text blob cache

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 113 matching lines @@
 bool Font::drawText(PaintCanvas* canvas,
                     const TextRunPaintInfo& runInfo,
                     const FloatPoint& point,
                     float deviceScaleFactor,
                     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;
 
-  if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
-    // we have a pre-cached blob -- happy joy!
-    canvas->drawTextBlob(runInfo.cachedTextBlob->get(), point.x(), point.y(),
-                         flags);
-    return true;
-  }
-
   GlyphBuffer glyphBuffer;
   buildGlyphBuffer(runInfo, glyphBuffer);
 
-  drawGlyphBuffer(canvas, flags, runInfo, glyphBuffer, point,
-                  deviceScaleFactor);
+  drawGlyphBuffer(canvas, flags, glyphBuffer, point, deviceScaleFactor);
   return true;
 }
 
 bool Font::drawBidiText(PaintCanvas* canvas,
                         const TextRunPaintInfo& runInfo,
                         const FloatPoint& point,
                         CustomFontNotReadyAction customFontNotReadyAction,
                         float deviceScaleFactor,
                         const PaintFlags& flags) const {
   // Don't draw anything while we are using custom fonts that are in the process
@@ skipping 27 matching lines @@
     subrun.setDirection(isRTL ? TextDirection::kRtl : TextDirection::kLtr);
     subrun.setDirectionalOverride(bidiRun->dirOverride(false));
 
     TextRunPaintInfo subrunInfo(subrun);
     subrunInfo.bounds = runInfo.bounds;
 
     // TODO: investigate blob consolidation/caching (technically,
     //       all subruns could be part of the same blob).
     GlyphBuffer glyphBuffer;
     float runWidth = buildGlyphBuffer(subrunInfo, glyphBuffer);
-    drawGlyphBuffer(canvas, flags, subrunInfo, glyphBuffer, currPoint,
-                    deviceScaleFactor);
+    drawGlyphBuffer(canvas, flags, glyphBuffer, currPoint, deviceScaleFactor);
 
     bidiRun = bidiRun->next();
     currPoint.move(runWidth, 0);
   }
 
   bidiRuns.deleteRuns();
   return true;
 }
 
 void Font::drawEmphasisMarks(PaintCanvas* canvas,
@@ skipping 14 matching lines @@
   ASSERT(emphasisGlyphData.fontData);
   if (!emphasisGlyphData.fontData)
     return;
 
   GlyphBuffer glyphBuffer;
   buildGlyphBuffer(runInfo, glyphBuffer, &emphasisGlyphData);
 
   if (glyphBuffer.isEmpty())
     return;
 
-  drawGlyphBuffer(canvas, flags, runInfo, glyphBuffer, point,
-                  deviceScaleFactor);
+  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;
 }
@@ skipping 10 matching lines @@
  public:
   GlyphBufferBloberizer(const GlyphBuffer& buffer,
                         const Font* font,
                         float deviceScaleFactor)
       : m_buffer(buffer),
         m_font(font),
         m_deviceScaleFactor(deviceScaleFactor),
         m_hasVerticalOffsets(buffer.hasVerticalOffsets()),
         m_index(0),
         m_endIndex(m_buffer.size()),
-        m_blobCount(0),
         m_rotation(buffer.isEmpty() ? NoRotation : computeBlobRotation(
                                                        buffer.fontDataAt(0))) {}
 
   bool done() const { return m_index >= m_endIndex; }
-  unsigned blobCount() const { return m_blobCount; }
 
   std::pair<sk_sp<SkTextBlob>, BlobRotation> next() {
     ASSERT(!done());
     const BlobRotation currentRotation = m_rotation;
 
     while (m_index < m_endIndex) {
       const SimpleFontData* fontData = m_buffer.fontDataAt(m_index);
       ASSERT(fontData);
 
       const BlobRotation newRotation = computeBlobRotation(fontData);
       if (newRotation != m_rotation) {
         // We're switching to an orientation which requires a different rotation
         //   => emit the pending blob (and start a new one with the new
         //      rotation).
         m_rotation = newRotation;
         break;
       }
 
       const unsigned start = m_index++;
       while (m_index < m_endIndex && m_buffer.fontDataAt(m_index) == fontData)
         m_index++;
 
       appendRun(start, m_index - start, fontData);
     }
 
-    m_blobCount++;
     return std::make_pair(m_builder.make(), currentRotation);
   }
 
  private:
   static BlobRotation computeBlobRotation(const SimpleFontData* font) {
     // For vertical upright text we need to compensate the inherited 90deg CW
     // rotation (using a 90deg CCW rotation).
     return (font->platformData().isVerticalAnyUpright() && font->verticalData())
                ? CCWRotation
                : NoRotation;
@@ skipping 34 matching lines @@
   }
 
   const GlyphBuffer& m_buffer;
   const Font* m_font;
   const float m_deviceScaleFactor;
   const bool m_hasVerticalOffsets;
 
   SkTextBlobBuilder m_builder;
   unsigned m_index;
   unsigned m_endIndex;
-  unsigned m_blobCount;
   BlobRotation m_rotation;
 };
 
 }  // anonymous namespace
 
 void Font::drawGlyphBuffer(PaintCanvas* canvas,
                            const PaintFlags& flags,
-                           const TextRunPaintInfo& runInfo,
                            const GlyphBuffer& glyphBuffer,
                            const FloatPoint& point,
                            float deviceScaleFactor) const {
   GlyphBufferBloberizer bloberizer(glyphBuffer, this, deviceScaleFactor);
-  std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
 
   while (!bloberizer.done()) {
-    blob = bloberizer.next();
+    auto blob = bloberizer.next();
     ASSERT(blob.first);
 
     PaintCanvasAutoRestore autoRestore(canvas, false);
     if (blob.second == CCWRotation) {
       canvas->save();
 
       SkMatrix m;
       m.setSinCos(-1, 0, point.x(), point.y());
       canvas->concat(m);
     }
 
     canvas->drawTextBlob(blob.first, point.x(), point.y(), flags);
   }
-
-  // Cache results when
-  //   1) requested by clients, and
-  //   2) the glyph buffer is encoded as a single blob, and
-  //   3) the blob is not upright/rotated
-  if (runInfo.cachedTextBlob && bloberizer.blobCount() == 1 &&
-      blob.second == NoRotation) {
-    ASSERT(!*runInfo.cachedTextBlob);
-    *runInfo.cachedTextBlob = std::move(blob.first);
-    ASSERT(*runInfo.cachedTextBlob);
-  }
 }
 
 static int getInterceptsFromBloberizer(const GlyphBuffer& glyphBuffer,
                                        const Font* font,
                                        const PaintFlags& flags,
                                        float deviceScaleFactor,
                                        const std::tuple<float, float>& bounds,
                                        SkScalar* interceptsBuffer) {
   SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
   GlyphBufferBloberizer bloberizer(glyphBuffer, font, deviceScaleFactor);
-  std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
 
   int numIntervals = 0;
   while (!bloberizer.done()) {
-    blob = bloberizer.next();
+    auto blob = bloberizer.next();
     DCHECK(blob.first);
 
     // GlyphBufferBloberizer 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.second == BlobRotation::CCWRotation)
       continue;
 
     SkScalar* offsetInterceptsBuffer = nullptr;
     if (interceptsBuffer)
       offsetInterceptsBuffer = &interceptsBuffer[numIntervals];
     numIntervals += flags.getTextBlobIntercepts(blob.first.get(), boundsArray,
                                                 offsetInterceptsBuffer);
   }
   return numIntervals;
 }
 
 void Font::getTextIntercepts(const TextRunPaintInfo& runInfo,
                              float deviceScaleFactor,
                              const PaintFlags& flags,
                              const std::tuple<float, float>& bounds,
                              Vector<TextIntercept>& intercepts) const {
   if (shouldSkipDrawing())
     return;
 
-  DCHECK(!runInfo.cachedTextBlob);
-
   GlyphBuffer glyphBuffer(GlyphBuffer::Type::TextIntercepts);
   buildGlyphBuffer(runInfo, glyphBuffer);
 
   // 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.
   int numIntervals = getInterceptsFromBloberizer(
       glyphBuffer, this, flags, deviceScaleFactor, bounds, nullptr);
   if (!numIntervals)
     return;
@@ skipping 169 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink