| // Copyright 2013 The Flutter Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "flutter/testing/mock_canvas.h" | |
| #include "flutter/fml/logging.h" | |
| #include "third_party/skia/include/core/SkImageInfo.h" | |
| #include "third_party/skia/include/core/SkPicture.h" | |
| #include "third_party/skia/include/core/SkSerialProcs.h" | |
| #include "third_party/skia/include/core/SkSize.h" | |
| #include "third_party/skia/include/core/SkTextBlob.h" | |
| namespace flutter { | |
| namespace testing { | |
| constexpr SkISize kSize = SkISize::Make(64, 64); | |
| MockCanvas::MockCanvas() | |
| : SkCanvasVirtualEnforcer<SkCanvas>(kSize.fWidth, kSize.fHeight), | |
| internal_canvas_(imageInfo().width(), imageInfo().height()), | |
| current_layer_(0) { | |
| internal_canvas_.addCanvas(this); | |
| } | |
| MockCanvas::~MockCanvas() { | |
| EXPECT_EQ(current_layer_, 0); | |
| } | |
| void MockCanvas::willSave() { | |
| draw_calls_.emplace_back( | |
| DrawCall{current_layer_, SaveData{current_layer_ + 1}}); | |
| current_layer_++; // Must go here; func params order of eval is undefined | |
| } | |
| SkCanvas::SaveLayerStrategy MockCanvas::getSaveLayerStrategy( | |
| const SaveLayerRec& rec) { | |
| // saveLayer calls this prior to running, so we use it to track saveLayer | |
| // calls | |
| draw_calls_.emplace_back(DrawCall{ | |
| current_layer_, | |
| SaveLayerData{rec.fBounds ? *rec.fBounds : SkRect(), | |
| rec.fPaint ? *rec.fPaint : SkPaint(), | |
| rec.fBackdrop ? sk_ref_sp<SkImageFilter>(rec.fBackdrop) | |
| : sk_sp<SkImageFilter>(), | |
| current_layer_ + 1}}); | |
| current_layer_++; // Must go here; func params order of eval is undefined | |
| return kNoLayer_SaveLayerStrategy; | |
| } | |
| void MockCanvas::willRestore() { | |
| FML_DCHECK(current_layer_ > 0); | |
| draw_calls_.emplace_back( | |
| DrawCall{current_layer_, RestoreData{current_layer_ - 1}}); | |
| current_layer_--; // Must go here; func params order of eval is undefined | |
| } | |
| void MockCanvas::didConcat(const SkMatrix& matrix) { | |
| draw_calls_.emplace_back(DrawCall{current_layer_, ConcatMatrixData{matrix}}); | |
| } | |
| void MockCanvas::didConcat44(const SkScalar matrix[]) { | |
| SkMatrix44 m44; | |
| m44.setColMajor(matrix); | |
| draw_calls_.emplace_back(DrawCall{current_layer_, ConcatMatrix44Data{m44}}); | |
| } | |
| void MockCanvas::didScale(SkScalar x, SkScalar y) { | |
| SkMatrix m; | |
| m.setScale(x, y); | |
| this->didConcat(m); | |
| } | |
| void MockCanvas::didTranslate(SkScalar x, SkScalar y) { | |
| SkMatrix m; | |
| m.setTranslate(x, y); | |
| this->didConcat(m); | |
| } | |
| void MockCanvas::didSetMatrix(const SkMatrix& matrix) { | |
| draw_calls_.emplace_back(DrawCall{current_layer_, SetMatrixData{matrix}}); | |
| } | |
| void MockCanvas::onDrawTextBlob(const SkTextBlob* text, | |
| SkScalar x, | |
| SkScalar y, | |
| const SkPaint& paint) { | |
| // This duplicates existing logic in SkCanvas::onDrawPicture | |
| // that should probably be split out so it doesn't need to be here as well. | |
| SkRect storage; | |
| const SkRect* bounds = nullptr; | |
| if (paint.canComputeFastBounds()) { | |
| storage = text->bounds().makeOffset(x, y); | |
| SkRect tmp; | |
| if (this->quickReject(paint.computeFastBounds(storage, &tmp))) { | |
| return; | |
| } | |
| bounds = &storage; | |
| } | |
| draw_calls_.emplace_back(DrawCall{ | |
| current_layer_, DrawTextData{text ? text->serialize(SkSerialProcs{}) | |
| : SkData::MakeUninitialized(0), | |
| paint, SkPoint::Make(x, y)}}); | |
| } | |
| void MockCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) { | |
| draw_calls_.emplace_back(DrawCall{current_layer_, DrawRectData{rect, paint}}); | |
| } | |
| void MockCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) { | |
| draw_calls_.emplace_back(DrawCall{current_layer_, DrawPathData{path, paint}}); | |
| } | |
| void MockCanvas::onDrawShadowRec(const SkPath& path, | |
| const SkDrawShadowRec& rec) { | |
| (void)rec; // Can't use b/c Skia keeps this type anonymous. | |
| draw_calls_.emplace_back(DrawCall{current_layer_, DrawShadowData{path}}); | |
| } | |
| void MockCanvas::onDrawPicture(const SkPicture* picture, | |
| const SkMatrix* matrix, | |
| const SkPaint* paint) { | |
| // This duplicates existing logic in SkCanvas::onDrawPicture | |
| // that should probably be split out so it doesn't need to be here as well. | |
| if (!paint || paint->canComputeFastBounds()) { | |
| SkRect bounds = picture->cullRect(); | |
| if (paint) { | |
| paint->computeFastBounds(bounds, &bounds); | |
| } | |
| if (matrix) { | |
| matrix->mapRect(&bounds); | |
| } | |
| if (this->quickReject(bounds)) { | |
| return; | |
| } | |
| } | |
| draw_calls_.emplace_back(DrawCall{ | |
| current_layer_, | |
| DrawPictureData{ | |
| picture ? picture->serialize() : SkData::MakeUninitialized(0), | |
| paint ? *paint : SkPaint(), matrix ? *matrix : SkMatrix()}}); | |
| } | |
| void MockCanvas::onClipRect(const SkRect& rect, | |
| SkClipOp op, | |
| ClipEdgeStyle style) { | |
| draw_calls_.emplace_back( | |
| DrawCall{current_layer_, ClipRectData{rect, op, style}}); | |
| } | |
| void MockCanvas::onClipRRect(const SkRRect& rrect, | |
| SkClipOp op, | |
| ClipEdgeStyle style) { | |
| draw_calls_.emplace_back( | |
| DrawCall{current_layer_, ClipRRectData{rrect, op, style}}); | |
| } | |
| void MockCanvas::onClipPath(const SkPath& path, | |
| SkClipOp op, | |
| ClipEdgeStyle style) { | |
| draw_calls_.emplace_back( | |
| DrawCall{current_layer_, ClipPathData{path, op, style}}); | |
| } | |
| bool MockCanvas::onDoSaveBehind(const SkRect*) { | |
| FML_DCHECK(false); | |
| return false; | |
| } | |
| void MockCanvas::onDrawAnnotation(const SkRect&, const char[], SkData*) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawDrawable(SkDrawable*, const SkMatrix*) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawPatch(const SkPoint[12], | |
| const SkColor[4], | |
| const SkPoint[4], | |
| SkBlendMode, | |
| const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawPaint(const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawBehind(const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawPoints(PointMode, | |
| size_t, | |
| const SkPoint[], | |
| const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawRegion(const SkRegion&, const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawOval(const SkRect&, const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawArc(const SkRect&, | |
| SkScalar, | |
| SkScalar, | |
| bool, | |
| const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawRRect(const SkRRect&, const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| #if defined(SK_SUPPORT_LEGACY_ONDRAWBITMAP_VIRTUALS) | |
| void MockCanvas::onDrawBitmap(const SkBitmap&, | |
| SkScalar, | |
| SkScalar, | |
| const SkPaint*) { | |
| FML_DCHECK(false); | |
| } | |
| #endif | |
| void MockCanvas::onDrawImage(const SkImage*, | |
| SkScalar, | |
| SkScalar, | |
| const SkPaint*) { | |
| FML_DCHECK(false); | |
| } | |
| #if defined(SK_SUPPORT_LEGACY_ONDRAWBITMAP_VIRTUALS) | |
| void MockCanvas::onDrawBitmapRect(const SkBitmap&, | |
| const SkRect*, | |
| const SkRect&, | |
| const SkPaint*, | |
| SrcRectConstraint) { | |
| FML_DCHECK(false); | |
| } | |
| #endif | |
| void MockCanvas::onDrawImageRect(const SkImage*, | |
| const SkRect*, | |
| const SkRect&, | |
| const SkPaint*, | |
| SrcRectConstraint) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawImageNine(const SkImage*, | |
| const SkIRect&, | |
| const SkRect&, | |
| const SkPaint*) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawImageLattice(const SkImage*, | |
| const Lattice&, | |
| const SkRect&, | |
| const SkPaint*) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawVerticesObject(const SkVertices*, | |
| SkBlendMode, | |
| const SkPaint&) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawAtlas(const SkImage*, | |
| const SkRSXform[], | |
| const SkRect[], | |
| const SkColor[], | |
| int, | |
| SkBlendMode, | |
| const SkRect*, | |
| const SkPaint*) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawEdgeAAQuad(const SkRect&, | |
| const SkPoint[4], | |
| QuadAAFlags, | |
| const SkColor4f&, | |
| SkBlendMode) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onDrawEdgeAAImageSet(const ImageSetEntry[], | |
| int, | |
| const SkPoint[], | |
| const SkMatrix[], | |
| const SkPaint*, | |
| SrcRectConstraint) { | |
| FML_DCHECK(false); | |
| } | |
| void MockCanvas::onClipRegion(const SkRegion&, SkClipOp) { | |
| FML_DCHECK(false); | |
| } | |
| bool operator==(const MockCanvas::SaveData& a, const MockCanvas::SaveData& b) { | |
| return a.save_to_layer == b.save_to_layer; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const MockCanvas::SaveData& data) { | |
| return os << data.save_to_layer; | |
| } | |
| bool operator==(const MockCanvas::SaveLayerData& a, | |
| const MockCanvas::SaveLayerData& b) { | |
| return a.save_bounds == b.save_bounds && a.restore_paint == b.restore_paint && | |
| a.backdrop_filter == b.backdrop_filter && | |
| a.save_to_layer == b.save_to_layer; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::SaveLayerData& data) { | |
| return os << data.save_bounds << " " << data.restore_paint << " " | |
| << data.backdrop_filter << " " << data.save_to_layer; | |
| } | |
| bool operator==(const MockCanvas::RestoreData& a, | |
| const MockCanvas::RestoreData& b) { | |
| return a.restore_to_layer == b.restore_to_layer; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::RestoreData& data) { | |
| return os << data.restore_to_layer; | |
| } | |
| bool operator==(const MockCanvas::ConcatMatrixData& a, | |
| const MockCanvas::ConcatMatrixData& b) { | |
| return a.matrix == b.matrix; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::ConcatMatrixData& data) { | |
| return os << data.matrix; | |
| } | |
| bool operator==(const MockCanvas::ConcatMatrix44Data& a, | |
| const MockCanvas::ConcatMatrix44Data& b) { | |
| return a.matrix == b.matrix; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::ConcatMatrix44Data& data) { | |
| return os << data.matrix; | |
| } | |
| bool operator==(const MockCanvas::SetMatrixData& a, | |
| const MockCanvas::SetMatrixData& b) { | |
| return a.matrix == b.matrix; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::SetMatrixData& data) { | |
| return os << data.matrix; | |
| } | |
| bool operator==(const MockCanvas::DrawRectData& a, | |
| const MockCanvas::DrawRectData& b) { | |
| return a.rect == b.rect && a.paint == b.paint; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawRectData& data) { | |
| return os << data.rect << " " << data.paint; | |
| } | |
| bool operator==(const MockCanvas::DrawPathData& a, | |
| const MockCanvas::DrawPathData& b) { | |
| return a.path == b.path && a.paint == b.paint; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawPathData& data) { | |
| return os << data.path << " " << data.paint; | |
| } | |
| bool operator==(const MockCanvas::DrawTextData& a, | |
| const MockCanvas::DrawTextData& b) { | |
| return a.serialized_text->equals(b.serialized_text.get()) && | |
| a.paint == b.paint && a.offset == b.offset; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawTextData& data) { | |
| return os << data.serialized_text << " " << data.paint << " " << data.offset; | |
| } | |
| bool operator==(const MockCanvas::DrawPictureData& a, | |
| const MockCanvas::DrawPictureData& b) { | |
| return a.serialized_picture->equals(b.serialized_picture.get()) && | |
| a.paint == b.paint && a.matrix == b.matrix; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawPictureData& data) { | |
| return os << data.serialized_picture << " " << data.paint << " " | |
| << data.matrix; | |
| } | |
| bool operator==(const MockCanvas::DrawShadowData& a, | |
| const MockCanvas::DrawShadowData& b) { | |
| return a.path == b.path; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawShadowData& data) { | |
| return os << data.path; | |
| } | |
| bool operator==(const MockCanvas::ClipRectData& a, | |
| const MockCanvas::ClipRectData& b) { | |
| return a.rect == b.rect && a.clip_op == b.clip_op && a.style == b.style; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::ClipRectData& data) { | |
| return os << data.rect << " " << data.clip_op << " " << data.style; | |
| } | |
| bool operator==(const MockCanvas::ClipRRectData& a, | |
| const MockCanvas::ClipRRectData& b) { | |
| return a.rrect == b.rrect && a.clip_op == b.clip_op && a.style == b.style; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::ClipRRectData& data) { | |
| return os << data.rrect << " " << data.clip_op << " " << data.style; | |
| } | |
| bool operator==(const MockCanvas::ClipPathData& a, | |
| const MockCanvas::ClipPathData& b) { | |
| return a.path == b.path && a.clip_op == b.clip_op && a.style == b.style; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::ClipPathData& data) { | |
| return os << data.path << " " << data.clip_op << " " << data.style; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const MockCanvas::DrawCallData& data) { | |
| std::visit([&os](auto& d) { os << d; }, data); | |
| return os; | |
| } | |
| bool operator==(const MockCanvas::DrawCall& a, const MockCanvas::DrawCall& b) { | |
| return a.layer == b.layer && a.data == b.data; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const MockCanvas::DrawCall& draw) { | |
| return os << "[Layer: " << draw.layer << ", Data: " << draw.data << "]"; | |
| } | |
| } // namespace testing | |
| } // namespace flutter |