Remove the call to getFontMetrics from SkBBoxRecord

src/core/SkPictureRecord.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPictureRecord.h"
 #include "SkTSearch.h"
 #include "SkPixelRef.h"
@@ skipping 383 matching lines @@
 
     SkAutoTDelete<SkPaint> dbmPaint(paintDict->unflatten(dbmPaintId));
     if (NULL == dbmPaint.get() || dbmPaint->getColor() != layerColor) {
         return false;
     }
 
     SkColor newColor = SkColorSetA(dbmPaint->getColor(),
                                    SkColorGetA(saveLayerPaint->getColor()));
     dbmPaint->setColor(newColor);
 
-    const int paintIndex = paintDict->find(*dbmPaint);
+    const SkFlatData* data = paintDict->findAndReturnFlat(*dbmPaint);
+    if (NULL == data) {
+        return false;
+    }
 
     // kill the saveLayer and alter the DBMR2R's paint to be the modified one
     convert_command_to_noop(writer, saveLayerInfo.fOffset);
     uint32_t* ptr = writer->peek32(dbmInfo.fOffset+dbmPaintOffset);
     SkASSERT(dbmPaintId == *ptr);
-    *ptr = paintIndex;
+    *ptr = data->index();
     return true;
 }
 
 /*
  * Restore has just been called (but not recorded), look back at the
  * matching save* and see if we are in the configuration:
  *   SAVE_LAYER (with NULL == bounds)
  *      SAVE
  *         CLIP_RECT
  *         DRAW_BITMAP|DRAW_BITMAP_MATRIX|DRAW_BITMAP_NINE|DRAW_BITMAP_RECT_TO_RECT
@@ skipping 539 matching lines @@
     uint32_t size = 5 * kUInt32Size;
     uint32_t initialOffset = this->addDraw(DRAW_SPRITE, &size);
     SkASSERT(initialOffset+getPaintOffset(DRAW_SPRITE, size) == fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addInt(left);
     addInt(top);
     validate(initialOffset, size);
 }
 
-// Return fontmetrics.fTop,fBottom in topbot[0,1], after they have been
-// tweaked by paint.computeFastBounds().
-//
-static void computeFontMetricsTopBottom(const SkPaint& paint, SkScalar topbot[2]) {
+void SkPictureRecord::ComputeFontMetricsTopBottom(const SkPaint& paint, SkScalar topbot[2]) {
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
     SkRect bounds;
     // construct a rect so we can see any adjustments from the paint.
     // we use 0,1 for left,right, just so the rect isn't empty
     bounds.set(0, metrics.fTop, SK_Scalar1, metrics.fBottom);
     (void)paint.computeFastBounds(bounds, &bounds);
     topbot[0] = bounds.fTop;
     topbot[1] = bounds.fBottom;
 }
 
 void SkPictureRecord::addFontMetricsTopBottom(const SkPaint& paint, const SkFlatData& flat,
                                               SkScalar minY, SkScalar maxY) {
-    if (!flat.isTopBotWritten()) {
-        computeFontMetricsTopBottom(paint, flat.writableTopBot());
-        SkASSERT(flat.isTopBotWritten());
-    }
+    WriteTopBot(paint, flat);
     addScalar(flat.topBot()[0] + minY);
     addScalar(flat.topBot()[1] + maxY);
 }
 
 void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
                       SkScalar y, const SkPaint& paint) {
     bool fast = !paint.isVerticalText() && paint.canComputeFastBounds();
 
     // op + paint index + length + 'length' worth of chars + x + y
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 2 * sizeof(SkScalar);
@@ skipping 95 matching lines @@
 #ifdef SK_DEBUG_SIZE
     fPointBytes += fWriter.size() - start;
     fPointWrites += points;
 #endif
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPosTextH(const void* text, size_t byteLength,
                           const SkScalar xpos[], SkScalar constY,
                           const SkPaint& paint) {
+
+    const SkFlatData* flatPaintData = this->getFlatPaintData(paint);
+    drawPosTextHImpl(text, byteLength, xpos, constY, paint, flatPaintData);
+}
+
+void SkPictureRecord::drawPosTextHImpl(const void* text, size_t byteLength,
+                          const SkScalar xpos[], SkScalar constY,
+                          const SkPaint& paint, const SkFlatData* flatPaintData) {
     size_t points = paint.countText(text, byteLength);
     if (0 == points)
         return;
 
     bool fast = !paint.isVerticalText() && paint.canComputeFastBounds();
 
     // op + paint index + length + 'length' worth of data + num points
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 1 * kUInt32Size;
     if (fast) {
         size += 2 * sizeof(SkScalar); // + top & bottom
     }
     // + y + the actual points
     size += 1 * kUInt32Size + points * sizeof(SkScalar);
-
     uint32_t initialOffset = this->addDraw(fast ? DRAW_POS_TEXT_H_TOP_BOTTOM : DRAW_POS_TEXT_H,
                                            &size);
-    const SkFlatData* flatPaintData = addPaint(paint);
     SkASSERT(flatPaintData);
+    addFlatPaint(flatPaintData);
+
     addText(text, byteLength);
     addInt(points);
 
 #ifdef SK_DEBUG_SIZE
     size_t start = fWriter.size();
 #endif
     if (fast) {
         addFontMetricsTopBottom(paint, *flatPaintData, constY, constY);
     }
     addScalar(constY);
@@ skipping 124 matching lines @@
 }
 
 void SkPictureRecord::addMatrix(const SkMatrix& matrix) {
     addMatrixPtr(&matrix);
 }
 
 void SkPictureRecord::addMatrixPtr(const SkMatrix* matrix) {
     this->addInt(matrix ? fMatrices.find(*matrix) : 0);
 }
 
+const SkFlatData* SkPictureRecord::getFlatPaintData(const SkPaint& paint) {
+    return fPaints.findAndReturnFlat(paint);
+}
+
 const SkFlatData* SkPictureRecord::addPaintPtr(const SkPaint* paint) {
-    const SkFlatData* data = paint ? fPaints.findAndReturnFlat(*paint) : NULL;
-    int index = data ? data->index() : 0;
+    const SkFlatData* data = paint ? getFlatPaintData(*paint) : NULL;
+    this->addFlatPaint(data);
+    return data;
+}
+
+void SkPictureRecord::addFlatPaint(const SkFlatData* flatPaint) {
+    int index = flatPaint ? flatPaint->index() : 0;
     this->addInt(index);
-    return data;
 }
 
 void SkPictureRecord::addPath(const SkPath& path) {
     if (NULL == fPathHeap) {
         fPathHeap = SkNEW(SkPathHeap);
     }
     addInt(fPathHeap->append(path));
 }
 
 void SkPictureRecord::addPicture(SkPicture& picture) {
@@ skipping 199 matching lines @@
 void SkPictureRecord::validateRegions() const {
     int count = fRegions.count();
     SkASSERT((unsigned) count < 0x1000);
     for (int index = 0; index < count; index++) {
         const SkFlatData* region = fRegions[index];
         SkASSERT(region);
 //        region->validate();
     }
 }
 #endif