Strip old backend recording down to essentials

src/core/SkPictureRecord.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPictureRecord_DEFINED
 #define SkPictureRecord_DEFINED
 
 #include "SkCanvas.h"
 #include "SkFlattenable.h"
 #include "SkPathHeap.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
 #include "SkPictureFlat.h"
 #include "SkTemplates.h"
 #include "SkWriter32.h"
 
-class SkBBoxHierarchy;
-class SkPictureStateTree;
-
 // These macros help with packing and unpacking a single byte value and
 // a 3 byte value into/out of a uint32_t
 #define MASK_24 0x00FFFFFF
 #define UNPACK_8_24(combined, small, large)             \
     small = (combined >> 24) & 0xFF;                    \
     large = combined & MASK_24;
 #define PACK_8_24(small, large) ((small << 24) | large)
 
 
 class SkPictureRecord : public SkCanvas {
@@ skipping 24 matching lines @@
                           const SkPoint vertices[], const SkPoint texs[],
                           const SkColor colors[], SkXfermode*,
                           const uint16_t indices[], int indexCount,
                               const SkPaint&) SK_OVERRIDE;
     virtual void drawData(const void*, size_t) SK_OVERRIDE;
     virtual void beginCommentGroup(const char* description) SK_OVERRIDE;
     virtual void addComment(const char* kywd, const char* value) SK_OVERRIDE;
     virtual void endCommentGroup() SK_OVERRIDE;
     virtual bool isDrawingToLayer() const SK_OVERRIDE;
 
-    void addFontMetricsTopBottom(const SkPaint& paint, const SkFlatData&,
-                                 SkScalar minY, SkScalar maxY);
-
     const SkTDArray<const SkPicture* >& getPictureRefs() const {
         return fPictureRefs;
     }
 
     const SkTDArray<const SkTextBlob* >& getTextBlobRefs() const {
         return fTextBlobRefs;
     }
 
     SkData* opData(bool deepCopy) const {
         this->validate(fWriter.bytesWritten(), 0);
@@ skipping 21 matching lines @@
         fRecordFlags = recordFlags;
     }
 
     const SkWriter32& writeStream() const {
         return fWriter;
     }
 
     void beginRecording();
     void endRecording();
 
-    void internalOnly_EnableOpts(bool optsEnabled) {
-        fOptsEnabled = optsEnabled;
-    }
-
 protected:
     void addNoOp();
 
 private:
     void handleOptimization(int opt);
     size_t recordRestoreOffsetPlaceholder(SkRegion::Op);
     void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
 
     SkTDArray<int32_t> fRestoreOffsetStack;
     int fFirstSavedLayerIndex;
@@ skipping 38 matching lines @@
     void addInt(int value) {
         fWriter.writeInt(value);
     }
     void addScalar(SkScalar scalar) {
         fWriter.writeScalar(scalar);
     }
 
     // The command at 'offset' in the skp uses the specified bitmap
     int addBitmap(const SkBitmap& bitmap);
     void addMatrix(const SkMatrix& matrix);
-    const SkFlatData* addPaint(const SkPaint& paint) { return this->addPaintPtr(&paint); }
-    const SkFlatData* addPaintPtr(const SkPaint* paint);
-    void addFlatPaint(const SkFlatData* flatPaint);
+    void addPaint(const SkPaint& paint) { this->addPaintPtr(&paint); }
+    void addPaintPtr(const SkPaint* paint);
     void addPatch(const SkPoint cubics[12]);
     void addPath(const SkPath& path);
     void addPicture(const SkPicture* picture);
     void addPoint(const SkPoint& point);
     void addPoints(const SkPoint pts[], int count);
     void addRect(const SkRect& rect);
     void addRectPtr(const SkRect* rect);
     void addIRect(const SkIRect& rect);
     void addIRectPtr(const SkIRect* rect);
     void addRRect(const SkRRect&);
@@ skipping 27 matching lines @@
     virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                             const SkPaint&) SK_OVERRIDE;
     virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                const SkPaint&) SK_OVERRIDE;
     virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                 SkScalar constY, const SkPaint&) SK_OVERRIDE;
     virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                   const SkMatrix* matrix, const SkPaint&) SK_OVERRIDE;
     virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint& paint) SK_OVERRIDE;
-    
+
     virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                              const SkPoint texCoords[4], SkXfermode* xmode,
                              const SkPaint& paint) SK_OVERRIDE;
 
     virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
     virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
     virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
     virtual void onClipRegion(const SkRegion&, SkRegion::Op) SK_OVERRIDE;
 
     virtual void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) SK_OVERRIDE;
 
-    // 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]);
-
-    // Make sure that flat has fTopBot written.
-    static void WriteTopBot(const SkPaint& paint, const SkFlatData& flat) {
-        if (!flat.isTopBotWritten()) {
-            ComputeFontMetricsTopBottom(paint, flat.writableTopBot());
-            SkASSERT(flat.isTopBotWritten());
-        }
-    }
-    // Will return a cached version when possible.
-    const SkFlatData* getFlatPaintData(const SkPaint& paint);
-    /**
-     * SkBBoxRecord::drawPosTextH gets a flat paint and uses it,
-     * then it calls this, using the extra parameter, to avoid duplication.
-     */
-    void drawPosTextHImpl(const void* text, size_t byteLength,
-                          const SkScalar xpos[], SkScalar constY,
-                          const SkPaint& paint, const SkFlatData* flatPaintData);
-
     int addPathToHeap(const SkPath& path);  // does not write to ops stream
 
     // These entry points allow the writing of matrices, clips, saves &
     // restores to be deferred (e.g., if the MC state is being collapsed and
     // only written out as needed).
     void recordConcat(const SkMatrix& matrix);
     void recordTranslate(const SkMatrix& matrix);
     void recordScale(const SkMatrix& matrix);
     size_t recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
     size_t recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
     size_t recordClipPath(int pathID, SkRegion::Op op, bool doAA);
     size_t recordClipRegion(const SkRegion& region, SkRegion::Op op);
     void recordSave();
     void recordSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags);
     void recordRestore(bool fillInSkips = true);
 
-    // These are set to NULL in our constructor, but may be changed by
-    // subclasses, in which case they will be SkSafeUnref'd in our destructor.
-    SkBBoxHierarchy* fBoundingHierarchy;
-    SkPictureStateTree* fStateTree;
-
     // Allocated in the constructor and managed by this class.
     SkBitmapHeap* fBitmapHeap;
 
 private:
     SkPictureContentInfo fContentInfo;
     SkAutoTUnref<SkPathHeap> fPathHeap;
 
     SkChunkFlatController fFlattenableHeap;
 
     SkPaintDictionary fPaints;
 
     SkWriter32 fWriter;
 
     // we ref each item in these arrays
     SkTDArray<const SkPicture*>  fPictureRefs;
     SkTDArray<const SkTextBlob*> fTextBlobRefs;
 
     uint32_t fRecordFlags;
-    bool     fOptsEnabled;
     int      fInitialSaveCount;
 
     friend class SkPictureData;   // for SkPictureData's SkPictureRecord-based constructor
     friend class SkPictureTester; // for unit testing
 
     typedef SkCanvas INHERITED;
 };
 
 #endif