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 "SkNinePatchIter.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkRect.h"
 #include "SkRemote.h"
 #include "SkShader.h"
 #include "SkTHash.h"
 
 namespace SkRemote {
 
@@ skipping 129 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
+            this->INHERITED::onDrawDrawable(drawable, matrix);
+        }
+
+        void onDrawPicture(const SkPicture* pic,
+                           const SkMatrix* matrix,
+                           const SkPaint* paint) override {
+            // TODO
+            this->INHERITED::onDrawPicture(pic, matrix, paint);
+        }
+
+        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 {
+            SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
+            this->onDrawImageNine(image, center, dst, paint);
+        }
+
+        void onDrawImageNine(const SkImage* image,
+                             const SkIRect& center,
+                             const SkRect& dst,
+                             const SkPaint* paint) override {
+            SkNinePatchIter iter(image->width(), image->height(), center, dst);
+            SkRect s,d;
+            while (iter.next(&s, &d)) {
+                this->onDrawImageRect(image, &s, d, paint, kStrict_SrcRectConstraint);
+            }
+        }
+
         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);
         }
 
+        // All clip calls need to call their parent method or we'll not get any quick rejects.
         void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
+            this->INHERITED::onClipRect(rect, op, edgeStyle);
             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