SkRemote: some images, many TODOs

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"
 #include "SkDrawLooper.h"
+#include "SkImage.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkRect.h"
 #include "SkRemote.h"
 #include "SkShader.h"
 #include "SkTHash.h"
 
@@ skipping 131 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 {
+            // TODO
+            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;
             path.addOval(oval);
             this->onDrawPath(path, paint);
@@ skipping 30 matching lines @@
                 fEncoder->strokePath(p, common, this->id(Stroke::CreateFrom(paint)));
             }
         }
 
         void onDrawPaint(const SkPaint& paint) override {
             SkPath path;
             path.setFillType(SkPath::kInverseWinding_FillType);  // Either inverse FillType is fine.
             this->onDrawPath(path, paint);
         }
 
+        void onDrawPoints(PointMode mode,
+                          size_t count,
+                          const SkPoint pts[],
+                          const SkPaint& paint) override {
+            // TODO
+        }
+
+        void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override {
+            // TODO
+        }
+
+        void onDrawPicture(const SkPicture* pic,
+                           const SkMatrix* matrix,
+                           const SkPaint* paint) override {
+            // TODO

[hal.canary, 2015/11/03 15:09:56]

Isn't 

     this->INHERITED::onDrawPicture(pic, matrix, paint);

better than dropping this call (for now)?

Or simpler:

    #include "SkCanvasPriv.h"
    SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
    picture->playback(this);

[mtklein, 2015/11/03 15:24:30]

Done.

+        }
+
+        void onDrawVertices(VertexMode vmode,
+                            int vertexCount,
+                            const SkPoint vertices[],
+                            const SkPoint texs[],
+                            const SkColor colors[],
+                            SkXfermode* xmode,
+                            const uint16_t indices[],
+                            int indexCount,
+                            const SkPaint& paint) override {
+            // TODO
+        }
+
+        void onDrawPatch(const SkPoint cubics[12],
+                         const SkColor colors[4],
+                         const SkPoint texCoords[4],
+                         SkXfermode* xmode,
+                         const SkPaint& paint) override {
+            // TODO
+        }
+
+        void onDrawAtlas(const SkImage* atlas,
+                         const SkRSXform xform[],
+                         const SkRect tex[],
+                         const SkColor colors[],
+                         int count,
+                         SkXfermode::Mode mode,
+                         const SkRect* cull,
+                         const SkPaint* paint) override {
+            // TODO
+        }
+
+        void onDrawBitmap(const SkBitmap& bitmap,
+                          SkScalar left,
+                          SkScalar top,
+                          const SkPaint* paint) override {
+            auto src = SkRect::MakeWH(bitmap.width(), bitmap.height()),
+                 dst = src.makeOffset(left, top);
+            this->onDrawBitmapRect(bitmap, &src, dst, paint, kStrict_SrcRectConstraint);
+        }
+
+        void onDrawBitmapRect(const SkBitmap& bitmap,
+                              const SkRect* src,
+                              const SkRect& dst,
+                              const SkPaint* paint,
+                              SrcRectConstraint constraint) override {
+            SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
+            this->onDrawImageRect(image, src, dst, paint, constraint);
+        }
+
+        void onDrawImage(const SkImage* image,
+                         SkScalar left,
+                         SkScalar top,
+                         const SkPaint* paint) override {
+            if (!image) {
+                return;
+            }
+            auto src = SkRect::MakeWH(image->width(), image->height()),
+                 dst = src.makeOffset(left, top);
+            this->onDrawImageRect(image, &src, dst, paint, kStrict_SrcRectConstraint);
+        }
+
+        void onDrawImageRect(const SkImage* image,
+                             const SkRect* src,
+                             const SkRect& dst,
+                             const SkPaint* paint,
+                             SrcRectConstraint constraint) override {
+            // TODO: this is all a (likely buggy) hack to get images drawing quickly.
+            if (!image) {
+                return;
+            }
+
+            auto bounds = SkRect::MakeWH(image->width(), image->height());
+            if (!src) {
+                src = &bounds;
+            }
+            auto matrix = SkMatrix::MakeRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
+
+            SkAutoTUnref<SkImage> subset;
+            if (src) {
+                if (!bounds.intersect(*src)) {
+                    return;
+                }
+                subset.reset(image->newSubset(bounds.roundOut()));
+                image = subset;
+            }
+
+            auto paintWithShader = paint ? *paint : SkPaint();
+            SkAutoTUnref<SkShader> shader(
+                image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix));
+            paintWithShader.setShader(shader);
+
+            this->onDrawRect(dst, paintWithShader);
+        }
+
+        void onDrawBitmapNine(const SkBitmap& bitmap,
+                              const SkIRect& center,
+                              const SkRect& dst,
+                              const SkPaint* paint) override {
+            // TODO

[hal.canary, 2015/11/03 15:04:01]

    SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
    this->onDrawImageNine(image, center, dst, paint);

[mtklein, 2015/11/03 15:24:31]

Done.

+        }
+
+        void onDrawImageNine(const SkImage* image,
+                             const SkIRect& center,
+                             const SkRect& dst,
+                             const SkPaint* paint) override {
+            // TODO

[hal.canary, 2015/11/03 15:04:01]

    SkNinePatchIter iter(image->width(), image->height(), center, dst);
    SkRect srcR, dstR;
    while (iter.next(&srcR, &dstR)) {
        this->onDrawImageRect(image, &srcR, dstR, paint,
                              SkCanvas::kStrict_SrcRectConstraint);
    }

[mtklein, 2015/11/03 15:24:31]

Done.

+        }
+
         void onDrawText(const void* text, size_t byteLength,
                         SkScalar x, SkScalar y, const SkPaint& paint) override {
             // Text-as-paths is a temporary hack.
             // TODO: send SkTextBlobs and SkTypefaces
             SkPath path;
             paint.getTextPath(text, byteLength, x, y, &path);
             this->onDrawPath(path, paint);
         }
 
         void onDrawPosText(const void* text, size_t byteLength,
                            const SkPoint pos[], const SkPaint& paint) override {
             // Text-as-paths is a temporary hack.
             // TODO: send SkTextBlobs and SkTypefaces
             SkPath path;
             paint.getPosTextPath(text, byteLength, pos, &path);
             this->onDrawPath(path, paint);
         }
 
         void onDrawPosTextH(const void* text, size_t byteLength,
                             const SkScalar xpos[], SkScalar constY, const SkPaint& paint) override {
             size_t length = paint.countText(text, byteLength);
             SkAutoTArray<SkPoint> pos(length);
             for(size_t i = 0; i < length; ++i) {
                 pos[i].set(xpos[i], constY);
             }
             this->onDrawPosText(text, byteLength, &pos[0], paint);
         }
 
         void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
+            this->INHERITED::onClipRect(rect, op, edgeStyle);

[hal.canary, 2015/11/03 15:04:01]

// Please add comment explaining why we need this.

[mtklein, 2015/11/03 15:24:31]

// Done.

             SkPath path;
             path.addRect(rect);
             this->onClipPath(path, op, edgeStyle);
         }
 
         void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
+            this->INHERITED::onClipRRect(rrect, op, edgeStyle);
             SkPath path;
             path.addRRect(rrect);
             this->onClipPath(path, op, edgeStyle);
         }
 
         void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
+            this->INHERITED::onClipPath(path, op, edgeStyle);
             fEncoder->clipPath(this->id(path), op, edgeStyle == kSoft_ClipEdgeStyle);
         }
 
+        void onClipRegion(const SkRegion& region, SkRegion::Op op) override {
+            this->INHERITED::onClipRegion(region, op);
+            // TODO
+        }
+
         Encoder* fEncoder;
+        typedef SkCanvas INHERITED;
     };
 
     SkCanvas* NewCanvas(Encoder* encoder) { return new Canvas(encoder); }
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
     class Decoder final : public Encoder {
     public:
         explicit Decoder(SkCanvas* canvas) : fCanvas(canvas) {}
 
@@ skipping 273 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