SkRemote: saveLayer

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 147 matching lines @@
         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 {
-            // TODO
+            SkPath path;
+            if (bounds) {
+                path.addRect(*bounds);
+            }
+            const SkPaint defaultPaint;
+            if (!paint) {
+                paint = &defaultPaint;
+            }
+            fEncoder->saveLayer(this->id(path), this->commonIDs(*paint), flags);
             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 287 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 {
+            SkPaint paint;
+            this->applyCommon(common, &paint);
+            SkRect rect;
+            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);
             this->applyCommon(common, &paint);
@@ skipping 143 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 {
+            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);
         }
         void strokePath(ID path, CommonIDs common, ID stroke) override {
@@ skipping 42 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