change signature for virtual related to saveLayer, passing SaveLayerRec

src/core/SkRemote.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotation.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
@@ skipping 145 matching lines @@
             Encoder::CommonIDs fIDs;
         };
 
         template <typename T>
         AutoID id(const T& val) { return AutoID(fEncoder, val); }
 
         AutoCommonIDs commonIDs(const SkPaint& paint) { return AutoCommonIDs(fEncoder, paint); }
 
         void   willSave() override { fEncoder->   save(); }
         void didRestore() override { fEncoder->restore(); }
-        SaveLayerStrategy willSaveLayer(const SkRect* bounds,
-                                        const SkPaint* paint,
-                                        SaveFlags flags) override {
+        SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec& rec) override {
             SkPath path;
-            if (bounds) {
-                path.addRect(*bounds);
+            if (rec.fBounds) {
+                path.addRect(*rec.fBounds);
             }
             const SkPaint defaultPaint;
+            const SkPaint* paint = rec.fPaint;
             if (!paint) {
                 paint = &defaultPaint;
             }
-            fEncoder->saveLayer(this->id(path), this->commonIDs(*paint), flags);
+            fEncoder->saveLayer(this->id(path), this->commonIDs(*paint), rec.fSaveLayerFlags);
             return kNoLayer_SaveLayerStrategy;
         }
 
         void    didConcat(const SkMatrix&) override { this->didSetMatrix(this->getTotalMatrix()); }
         void didSetMatrix(const SkMatrix& matrix) override {
             fEncoder->setMatrix(this->id(matrix));
         }
 
         void onDrawOval(const SkRect& oval, const SkPaint& paint) override {
             SkPath path;
@@ skipping 305 matching lines @@
             paint->setMaskFilter (fMaskFilter .find(common.maskfilter));
             paint->setColorFilter(fColorFilter.find(common.colorfilter));
             paint->setRasterizer (fRasterizer .find(common.rasterizer));
             paint->setLooper     (fDrawLooper .find(common.looper));
             paint->setImageFilter(fImageFilter.find(common.imagefilter));
             paint->setAnnotation (fAnnotation .find(common.annotation));
         }
 
         void    save() override { fCanvas->save(); }
         void restore() override { fCanvas->restore(); }
-        void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveFlags flags) override {
+        void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveLayerFlags flags) override {
             SkPaint paint;
             this->applyCommon(common, &paint);
             SkRect rect;
-            fCanvas->saveLayer(fPath.find(bounds).isRect(&rect) ? &rect : nullptr, &paint, flags);
+
+            fCanvas->saveLayer({ fPath.find(bounds).isRect(&rect) ? &rect : nullptr,
+                                 &paint, flags });
         }
 
         void setMatrix(ID matrix) override { fCanvas->setMatrix(fMatrix.find(matrix)); }
 
         void clipPath(ID path, SkRegion::Op op, bool aa) override {
             fCanvas->clipPath(fPath.find(path), op, aa);
         }
         void fillPath(ID path, CommonIDs common) override {
             SkPaint paint;
             paint.setStyle(SkPaint::kFill_Style);
@@ skipping 159 matching lines @@
         ID define(SkColorFilter*    v) override { return this->define(&fColorFilter, v); }
         ID define(SkRasterizer*     v) override { return this->define(&fRasterizer , v); }
         ID define(SkDrawLooper*     v) override { return this->define(&fDrawLooper , v); }
         ID define(SkImageFilter*    v) override { return this->define(&fImageFilter, v); }
         ID define(SkAnnotation*     v) override { return this->define(&fAnnotation , v); }
 
         void undefine(ID) override {}
 
         void    save() override { fWrapped->   save(); }
         void restore() override { fWrapped->restore(); }
-        void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveFlags flags) override {
+        void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveLayerFlags flags) override {
             fWrapped->saveLayer(bounds, common, flags);
         }
 
         void setMatrix(ID matrix) override { fWrapped->setMatrix(matrix); }
 
         void clipPath(ID path, SkRegion::Op op, bool aa) override {
             fWrapped->clipPath(path, op, aa);
         }
         void fillPath(ID path, CommonIDs common) override {
             fWrapped->fillPath(path, common);
@@ skipping 51 matching lines @@
         RefKeyMap<SkDrawLooper    , Type::kDrawLooper > fDrawLooper;
         RefKeyMap<SkImageFilter   , Type::kImageFilter> fImageFilter;
         RefKeyMap<SkAnnotation    , Type::kAnnotation > fAnnotation;
 
         Encoder* fWrapped;
     };
 
     Encoder* NewCachingEncoder(Encoder* wrapped) { return new CachingEncoder(wrapped); }
 
 } // namespace SkRemote