From bada1885da479d948f065182d6dfa85a1140bda5 Mon Sep 17 00:00:00 2001 From: reed Date: Mon, 21 Dec 2015 13:09:44 -0800 Subject: [PATCH] hide old SaveFlags, but keep them available (for now) for Android BUG=skia: GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1535993003 requires https://codereview.chromium.org/1537203002/# to land in chrome first (android should be safe) Review URL: https://codereview.chromium.org/1535993003 --- include/core/SkCanvas.h | 33 +++++++++++++++++++++++++++++---- src/core/SkCanvas.cpp | 14 +++++++++++++- src/core/SkPicturePlayback.cpp | 27 ++++++++++++++++++++++++--- 3 files changed, 66 insertions(+), 8 deletions(-) diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h index ae0dc38202..854611aec1 100644 --- a/include/core/SkCanvas.h +++ b/include/core/SkCanvas.h @@ -37,6 +37,16 @@ class SkSurface; class SkSurface_Base; class SkTextBlob; +/* + * If you want the legacy cliptolayer flag (i.e. android), then you must have the new + * legacy saveflags. + */ +#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG +#ifndef SK_SUPPORT_LEGACY_SAVEFLAGS + #define SK_SUPPORT_LEGACY_SAVEFLAGS +#endif +#endif + /** \class SkCanvas A Canvas encapsulates all of the state about drawing into a device (bitmap). @@ -53,6 +63,10 @@ class SkTextBlob; etc. */ class SK_API SkCanvas : public SkRefCnt { + enum PrivateSaveLayerFlags { + kDontClipToLayer_PrivateSaveLayerFlag = 1 << 31, + }; + public: /** * Attempt to allocate raster canvas, matching the ImageInfo, that will draw directly into the @@ -281,6 +295,7 @@ public: /////////////////////////////////////////////////////////////////////////// +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS enum SaveFlags { /** save the matrix state, restoring it on restore() */ // [deprecated] kMatrix_SaveFlag = 0x01, @@ -307,6 +322,7 @@ public: #endif kARGB_ClipLayer_SaveFlag = 0x1F }; +#endif /** This call saves the current matrix, clip, and drawFilter, and pushes a copy onto a private stack. Subsequent calls to translate, scale, @@ -343,6 +359,7 @@ public: */ int saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint); +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS /** DEPRECATED - use saveLayer(const SkRect*, const SkPaint*) instead. This behaves the same as saveLayer(const SkRect*, const SkPaint*), @@ -360,6 +377,7 @@ public: */ SK_ATTR_EXTERNALLY_DEPRECATED("SaveFlags use is deprecated") int saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags); +#endif /** This behaves the same as save(), but in addition it allocates an offscreen bitmap. All drawing calls are directed there, and only when @@ -374,6 +392,7 @@ public: */ int saveLayerAlpha(const SkRect* bounds, U8CPU alpha); +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS /** DEPRECATED - use saveLayerAlpha(const SkRect*, U8CPU) instead. This behaves the same as saveLayerAlpha(const SkRect*, U8CPU), @@ -390,10 +409,15 @@ public: */ SK_ATTR_EXTERNALLY_DEPRECATED("SaveFlags use is deprecated") int saveLayerAlpha(const SkRect* bounds, U8CPU alpha, SaveFlags flags); +#endif enum { kIsOpaque_SaveLayerFlag = 1 << 0, kPreserveLCDText_SaveLayerFlag = 1 << 1, + +#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG + kDontClipToLayer_Legacy_SaveLayerFlag = kDontClipToLayer_PrivateSaveLayerFlag, +#endif }; typedef uint32_t SaveLayerFlags; @@ -1330,12 +1354,11 @@ protected: const SkImageFilter* imageFilter = NULL); private: - enum PrivateSaveLayerFlags { - kDontClipToLayer_PrivateSaveLayerFlag = 1 << 31, - }; - static bool BoundsAffectsClip(SaveLayerFlags); +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS static uint32_t SaveFlagsToSaveLayerFlags(SaveFlags); +#endif + static SaveLayerFlags LegacySaveFlagsToSaveLayerFlags(uint32_t legacySaveFlags); enum ShaderOverrideOpacity { kNone_ShaderOverrideOpacity, //!< there is no overriding shader (bitmap or image) @@ -1574,6 +1597,7 @@ private: size_t fRowBytes; }; +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS static inline SkCanvas::SaveFlags operator|(const SkCanvas::SaveFlags lhs, const SkCanvas::SaveFlags rhs) { return static_cast(static_cast(lhs) | static_cast(rhs)); @@ -1584,6 +1608,7 @@ static inline SkCanvas::SaveFlags& operator|=(SkCanvas::SaveFlags& lhs, lhs = lhs | rhs; return lhs; } +#endif class SkCanvasClipVisitor { public: diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp index a232177c6b..68afc187a2 100644 --- a/src/core/SkCanvas.cpp +++ b/src/core/SkCanvas.cpp @@ -1122,6 +1122,7 @@ bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveLayerFlags saveLayerFlag return true; } +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS uint32_t SkCanvas::SaveFlagsToSaveLayerFlags(SaveFlags flags) { uint32_t layerFlags = 0; @@ -1133,14 +1134,17 @@ uint32_t SkCanvas::SaveFlagsToSaveLayerFlags(SaveFlags flags) { } return layerFlags; } +#endif int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint) { return this->saveLayer(SaveLayerRec(bounds, paint, 0)); } +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) { return this->saveLayer(SaveLayerRec(bounds, paint, SaveFlagsToSaveLayerFlags(flags))); } +#endif int SkCanvas::saveLayerPreserveLCDTextRequests(const SkRect* bounds, const SkPaint* paint) { return this->saveLayer(SaveLayerRec(bounds, paint, kPreserveLCDText_SaveLayerFlag)); @@ -1269,9 +1273,16 @@ void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy stra } int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha) { - return this->saveLayerAlpha(bounds, alpha, kARGB_ClipLayer_SaveFlag); + if (0xFF == alpha) { + return this->saveLayer(bounds, nullptr); + } else { + SkPaint tmpPaint; + tmpPaint.setAlpha(alpha); + return this->saveLayer(bounds, &tmpPaint); + } } +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha, SaveFlags flags) { if (0xFF == alpha) { @@ -1282,6 +1293,7 @@ int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha, return this->saveLayer(bounds, &tmpPaint, flags); } } +#endif void SkCanvas::internalRestore() { SkASSERT(fMCStack.count() != 0); diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp index 187eeb96e1..82b8f0e578 100644 --- a/src/core/SkPicturePlayback.cpp +++ b/src/core/SkPicturePlayback.cpp @@ -16,6 +16,28 @@ #include "SkTDArray.h" #include "SkTypes.h" +// matches old SkCanvas::SaveFlags +enum LegacySaveFlags { + kHasAlphaLayer_LegacySaveFlags = 0x04, + kClipToLayer_LegacySaveFlags = 0x10, +}; +#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS +static_assert(kHasAlphaLayer_LegacySaveFlags == (int)SkCanvas::kHasAlphaLayer_SaveFlag, ""); +static_assert(kClipToLayer_LegacySaveFlags == (int)SkCanvas::kClipToLayer_SaveFlag, ""); +#endif + +SkCanvas::SaveLayerFlags SkCanvas::LegacySaveFlagsToSaveLayerFlags(uint32_t flags) { + uint32_t layerFlags = 0; + + if (0 == (flags & kClipToLayer_LegacySaveFlags)) { + layerFlags |= SkCanvas::kDontClipToLayer_PrivateSaveLayerFlag; + } + if (0 == (flags & kHasAlphaLayer_LegacySaveFlags)) { + layerFlags |= kIsOpaque_SaveLayerFlag; + } + return layerFlags; +} + /* * Read the next op code and chunk size from 'reader'. The returned size * is the entire size of the chunk (including the opcode). Thus, the @@ -458,9 +480,8 @@ void SkPicturePlayback::handleOp(SkReader32* reader, case SAVE_LAYER_SAVEFLAGS_DEPRECATED: { const SkRect* boundsPtr = get_rect_ptr(reader); const SkPaint* paint = fPictureData->getPaint(reader); - const SkCanvas::SaveFlags flags = (SkCanvas::SaveFlags)reader->readInt(); - canvas->saveLayer(SkCanvas::SaveLayerRec(boundsPtr, paint, - SkCanvas::SaveFlagsToSaveLayerFlags(flags))); + auto flags = SkCanvas::LegacySaveFlagsToSaveLayerFlags(reader->readInt()); + canvas->saveLayer(SkCanvas::SaveLayerRec(boundsPtr, paint, flags)); } break; case SAVE_LAYER_SAVELAYERFLAGS: { const SkRect* boundsPtr = get_rect_ptr(reader);