change signature for virtual related to saveLayer, passing SaveLayerRec

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 "SkDevice.h"
 #include "SkImage_Base.h"
@@ skipping 65 matching lines @@
         1,  // DRAW_RECT - right after op code
         1,  // DRAW_RRECT - right after op code
         1,  // DRAW_SPRITE - right after op code
         1,  // DRAW_TEXT - right after op code
         1,  // DRAW_TEXT_ON_PATH - right after op code
         1,  // DRAW_TEXT_TOP_BOTTOM - right after op code
         1,  // DRAW_VERTICES - right after op code
         0,  // RESTORE - no paint
         0,  // ROTATE - no paint
         0,  // SAVE - no paint
-        0,  // SAVE_LAYER - see below - this paint's location varies
+        0,  // SAVE_LAYER_SAVEFLAGS_DEPRECATED - see below - this paint's location varies
         0,  // SCALE - no paint
         0,  // SET_MATRIX - no paint
         0,  // SKEW - no paint
         0,  // TRANSLATE - no paint
         0,  // NOOP - no paint
         0,  // BEGIN_GROUP - no paint
         0,  // COMMENT - no paint
         0,  // END_GROUP - no paint
         1,  // DRAWDRRECT - right after op code
         0,  // PUSH_CULL - no paint
         0,  // POP_CULL - no paint
         1,  // DRAW_PATCH - right after op code
         1,  // DRAW_PICTURE_MATRIX_PAINT - right after op code
         1,  // DRAW_TEXT_BLOB- right after op code
         1,  // DRAW_IMAGE - right after op code
         1,  // DRAW_IMAGE_RECT_STRICT - right after op code
         1,  // DRAW_ATLAS - right after op code
         1,  // DRAW_IMAGE_NINE - right after op code
         1,  // DRAW_IMAGE_RECT - right after op code
+        0,  // SAVE_LAYER_SAVELAYERFLAGS - see below - this paint's location varies
     };
 
     static_assert(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1, "need_to_be_in_sync");
     SkASSERT((unsigned)op <= (unsigned)LAST_DRAWTYPE_ENUM);
 
     int overflow = 0;
     if (0 != (opSize & ~MASK_24) || opSize == MASK_24) {
         // This op's size overflows so an extra uint32_t will be written
         // after the op code
         overflow = sizeof(uint32_t);
     }
 
-    if (SAVE_LAYER == op) {
+    SkASSERT(SAVE_LAYER_SAVEFLAGS_DEPRECATED != op);
+    if (SAVE_LAYER_SAVELAYERFLAGS == op) {
         static const uint32_t kSaveLayerNoBoundsPaintOffset = 2 * kUInt32Size;
         static const uint32_t kSaveLayerWithBoundsPaintOffset = 2 * kUInt32Size + sizeof(SkRect);
 
         if (kSaveLayerNoBoundsSize == opSize) {
             return kSaveLayerNoBoundsPaintOffset + overflow;
         } else {
             SkASSERT(kSaveLayerWithBoundsSize == opSize);
             return kSaveLayerWithBoundsPaintOffset + overflow;
         }
     }
@@ skipping 15 matching lines @@
 void SkPictureRecord::recordSave() {
     fContentInfo.onSave();
 
     // op only
     size_t size = kSaveSize;
     size_t initialOffset = this->addDraw(SAVE, &size);
 
     this->validate(initialOffset, size);
 }
 
-SkCanvas::SaveLayerStrategy SkPictureRecord::willSaveLayer(const SkRect* bounds,
-                                                           const SkPaint* paint, SaveFlags flags) {
+SkCanvas::SaveLayerStrategy SkPictureRecord::getSaveLayerStrategy(const SaveLayerRec& rec) {
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
-    this->recordSaveLayer(bounds, paint, flags);
+    this->recordSaveLayer(rec);
 
-    this->INHERITED::willSaveLayer(bounds, paint, flags);
+    (void)this->INHERITED::getSaveLayerStrategy(rec);
     /*  No need for a (potentially very big) layer which we don't actually need
         at this time (and may not be able to afford since during record our
         clip starts out the size of the picture, which is often much larger
         than the size of the actual device we'll use during playback).
      */
     return kNoLayer_SaveLayerStrategy;
 }
 
-void SkPictureRecord::recordSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                      SaveFlags flags) {
+void SkPictureRecord::recordSaveLayer(const SaveLayerRec& rec) {
     fContentInfo.onSaveLayer();
 
     // op + bool for 'bounds'
     size_t size = 2 * kUInt32Size;
-    if (bounds) {
-        size += sizeof(*bounds); // + rect
+    if (rec.fBounds) {
+        size += sizeof(*rec.fBounds); // + rect
     }
     // + paint index + flags
     size += 2 * kUInt32Size;
 
     SkASSERT(kSaveLayerNoBoundsSize == size || kSaveLayerWithBoundsSize == size);
 
-    size_t initialOffset = this->addDraw(SAVE_LAYER, &size);
-    this->addRectPtr(bounds);
-    SkASSERT(initialOffset+get_paint_offset(SAVE_LAYER, size) == fWriter.bytesWritten());
-    this->addPaintPtr(paint);
-    this->addInt(flags);
+    size_t initialOffset = this->addDraw(SAVE_LAYER_SAVELAYERFLAGS, &size);
+    this->addRectPtr(rec.fBounds);
+    SkASSERT(initialOffset+get_paint_offset(SAVE_LAYER_SAVELAYERFLAGS, size) == fWriter.bytesWritten());
+    this->addPaintPtr(rec.fPaint);
+    this->addInt(rec.fSaveLayerFlags);
 
     this->validate(initialOffset, size);
 }
 
 #ifdef SK_DEBUG
 /*
  * Read the op code from 'offset' in 'writer' and extract the size too.
  */
 static DrawType peek_op_and_size(SkWriter32* writer, size_t offset, uint32_t* size) {
     uint32_t peek = writer->readTAt<uint32_t>(offset);
@@ skipping 115 matching lines @@
         fWriter.overwriteTAt(offset, restoreOffset);
         offset = peek;
     }
 
 #ifdef SK_DEBUG
     // offset of 0 has been disabled, so we skip it
     if (offset > 0) {
         // assert that the final offset value points to a save verb
         uint32_t opSize;
         DrawType drawOp = peek_op_and_size(&fWriter, -offset, &opSize);
-        SkASSERT(SAVE == drawOp || SAVE_LAYER == drawOp);
+        SkASSERT(SAVE_LAYER_SAVEFLAGS_DEPRECATED != drawOp);
+        SkASSERT(SAVE == drawOp || SAVE_LAYER_SAVELAYERFLAGS == drawOp);
     }
 #endif
 }
 
 void SkPictureRecord::beginRecording() {
     // we have to call this *after* our constructor, to ensure that it gets
     // recorded. This is balanced by restoreToCount() call from endRecording,
     // which in-turn calls our overridden restore(), so those get recorded too.
     fInitialSaveCount = this->save();
 }
@@ skipping 716 matching lines @@
 void SkPictureRecord::addTextBlob(const SkTextBlob *blob) {
     int index = fTextBlobRefs.count();
     *fTextBlobRefs.append() = blob;
     blob->ref();
     // follow the convention of recording a 1-based index
     this->addInt(index + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////