Revert[2] "remove SK_SUPPORT_LEGACY_CLIP_REGIONOPS"
This reverts commit a129dfef2aaab0b5995cdf1ab7b2cdd41c29cf72.
BUG=skia:
Change-Id: I717de6e5fcd4516aa684b014b1414b0f82ac2b91
Reviewed-on: https://skia-review.googlesource.com/5722
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Derek Sollenberger <djsollen@google.com>
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 2dff8e9..430556d 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -342,7 +342,7 @@
bool next() {
if (fMultiDeviceCS && fDevice) {
// remove the previous device's bounds
- fMultiDeviceCS->clipDevRect(compute_device_bounds(fDevice), SkCanvas::kDifference_Op);
+ fMultiDeviceCS->clipDevRect(compute_device_bounds(fDevice), kDifference_SkClipOp);
}
// skip over recs with empty clips
@@ -1104,7 +1104,7 @@
if (BoundsAffectsClip(saveLayerFlags)) {
// Simplify the current clips since they will be applied properly during restore()
- fClipStack->clipDevRect(ir, kReplace_Op);
+ fClipStack->clipDevRect(ir, kReplace_SkClipOp);
fMCRec->fRasterClip.setRect(ir);
fDeviceClipBounds = qr_clip_bounds(ir);
}
@@ -1522,13 +1522,13 @@
//////////////////////////////////////////////////////////////////////////////
-void SkCanvas::clipRect(const SkRect& rect, ClipOp op, bool doAA) {
+void SkCanvas::clipRect(const SkRect& rect, SkClipOp op, bool doAA) {
this->checkForDeferredSave();
ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
this->onClipRect(rect, op, edgeStyle);
}
-void SkCanvas::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle) {
const bool isAA = kSoft_ClipEdgeStyle == edgeStyle;
AutoValidateClip avc(this);
fClipStack->clipRect(rect, fMCRec->fMatrix, op, isAA);
@@ -1538,7 +1538,7 @@
fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
}
-void SkCanvas::clipRRect(const SkRRect& rrect, ClipOp op, bool doAA) {
+void SkCanvas::clipRRect(const SkRRect& rrect, SkClipOp op, bool doAA) {
this->checkForDeferredSave();
ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
if (rrect.isRect()) {
@@ -1548,7 +1548,7 @@
}
}
-void SkCanvas::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle) {
AutoValidateClip avc(this);
fDeviceCMDirty = true;
@@ -1561,7 +1561,7 @@
return;
}
-void SkCanvas::clipPath(const SkPath& path, ClipOp op, bool doAA) {
+void SkCanvas::clipPath(const SkPath& path, SkClipOp op, bool doAA) {
this->checkForDeferredSave();
ClipEdgeStyle edgeStyle = doAA ? kSoft_ClipEdgeStyle : kHard_ClipEdgeStyle;
@@ -1586,7 +1586,7 @@
this->onClipPath(path, op, edgeStyle);
}
-void SkCanvas::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkCanvas::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) {
AutoValidateClip avc(this);
fDeviceCMDirty = true;
@@ -1601,19 +1601,19 @@
isAA = getClipStack()->asPath(&tempPath);
rasterClipPath = &tempPath;
matrix = &SkMatrix::I();
- op = kReplace_Op;
+ op = kReplace_SkClipOp;
}
fMCRec->fRasterClip.op(*rasterClipPath, *matrix, this->getTopLayerBounds(), (SkRegion::Op)op,
isAA);
fDeviceClipBounds = qr_clip_bounds(fMCRec->fRasterClip.getBounds());
}
-void SkCanvas::clipRegion(const SkRegion& rgn, ClipOp op) {
+void SkCanvas::clipRegion(const SkRegion& rgn, SkClipOp op) {
this->checkForDeferredSave();
this->onClipRegion(rgn, op);
}
-void SkCanvas::onClipRegion(const SkRegion& rgn, ClipOp op) {
+void SkCanvas::onClipRegion(const SkRegion& rgn, SkClipOp op) {
AutoValidateClip avc(this);
fDeviceCMDirty = true;
@@ -3383,13 +3383,6 @@
///////////////////////////////////////////////////////////////////////////////
-const SkCanvas::ClipOp SkCanvas::kDifference_Op;
-const SkCanvas::ClipOp SkCanvas::kIntersect_Op;
-const SkCanvas::ClipOp SkCanvas::kUnion_Op;
-const SkCanvas::ClipOp SkCanvas::kXOR_Op;
-const SkCanvas::ClipOp SkCanvas::kReverseDifference_Op;
-const SkCanvas::ClipOp SkCanvas::kReplace_Op;
-
static_assert((int)SkRegion::kDifference_Op == (int)kDifference_SkClipOp, "");
static_assert((int)SkRegion::kIntersect_Op == (int)kIntersect_SkClipOp, "");
static_assert((int)SkRegion::kUnion_Op == (int)kUnion_SkClipOp, "");
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index f155b49..1a1e85f 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -83,7 +83,7 @@
visitor->clipRect(this->getRect(), this->getOp(), this->isAA());
break;
case kEmpty_Type:
- visitor->clipRect(kEmptyRect, SkCanvas::kIntersect_Op, false);
+ visitor->clipRect(kEmptyRect, kIntersect_SkClipOp, false);
break;
}
}
@@ -111,7 +111,7 @@
}
}
-void SkClipStack::Element::initPath(int saveCount, const SkPath& path, SkCanvas::ClipOp op,
+void SkClipStack::Element::initPath(int saveCount, const SkPath& path, SkClipOp op,
bool doAA) {
if (!path.isInverseFillType()) {
SkRect r;
@@ -176,16 +176,16 @@
SkASSERT(!fPath.isValid());
}
-bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkCanvas::ClipOp op) const {
+bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkClipOp op) const {
if (kEmpty_Type == fType &&
- (SkCanvas::kDifference_Op == op || SkCanvas::kIntersect_Op == op)) {
+ (kDifference_SkClipOp == op || kIntersect_SkClipOp == op)) {
return true;
}
// Only clips within the same save/restore frame (as captured by
// the save count) can be merged
return fSaveCount == saveCount &&
- SkCanvas::kIntersect_Op == op &&
- (SkCanvas::kIntersect_Op == fOp || SkCanvas::kReplace_Op == fOp);
+ kIntersect_SkClipOp == op &&
+ (kIntersect_SkClipOp == fOp || kReplace_SkClipOp == fOp);
}
bool SkClipStack::Element::rectRectIntersectAllowed(const SkRect& newR, bool newAA) const {
@@ -399,9 +399,9 @@
fFiniteBound = this->getRect();
fFiniteBoundType = kNormal_BoundsType;
- if (SkCanvas::kReplace_Op == fOp ||
- (SkCanvas::kIntersect_Op == fOp && nullptr == prior) ||
- (SkCanvas::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
+ if (kReplace_SkClipOp == fOp ||
+ (kIntersect_SkClipOp == fOp && nullptr == prior) ||
+ (kIntersect_SkClipOp == fOp && prior->fIsIntersectionOfRects &&
prior->rectRectIntersectAllowed(this->getRect(), fDoAA))) {
fIsIntersectionOfRects = true;
}
@@ -460,28 +460,28 @@
// Now integrate with clip with the prior clips
switch (fOp) {
- case SkCanvas::kDifference_Op:
+ case kDifference_SkClipOp:
this->combineBoundsDiff(combination, prevFinite);
break;
- case SkCanvas::kXOR_Op:
+ case kXOR_SkClipOp:
this->combineBoundsXOR(combination, prevFinite);
break;
- case SkCanvas::kUnion_Op:
+ case kUnion_SkClipOp:
this->combineBoundsUnion(combination, prevFinite);
break;
- case SkCanvas::kIntersect_Op:
+ case kIntersect_SkClipOp:
this->combineBoundsIntersection(combination, prevFinite);
break;
- case SkCanvas::kReverseDifference_Op:
+ case kReverseDifference_SkClipOp:
this->combineBoundsRevDiff(combination, prevFinite);
break;
- case SkCanvas::kReplace_Op:
+ case kReplace_SkClipOp:
// Replace just ignores everything prior
// The current clip's bound information is already filled in
// so nothing to do
break;
default:
- SkDebugf("SkCanvas::ClipOp error\n");
+ SkDebugf("SkClipOp error\n");
SkASSERT(0);
break;
}
@@ -608,7 +608,7 @@
Iter iter(*this, Iter::kTop_IterStart);
const Element* element = iter.prev();
while (element != nullptr) {
- if (SkCanvas::kIntersect_Op != element->getOp() && SkCanvas::kReplace_Op != element->getOp())
+ if (kIntersect_SkClipOp != element->getOp() && kReplace_SkClipOp != element->getOp())
return false;
if (element->isInverseFilled()) {
// Part of 'rect' could be trimmed off by the inverse-filled clip element
@@ -620,7 +620,7 @@
return false;
}
}
- if (SkCanvas::kReplace_Op == element->getOp()) {
+ if (kReplace_SkClipOp == element->getOp()) {
break;
}
element = iter.prev();
@@ -633,7 +633,7 @@
Iter iter(*this, Iter::kTop_IterStart);
const Element* element = iter.prev();
while (element != nullptr) {
- if (SkCanvas::kIntersect_Op != element->getOp() && SkCanvas::kReplace_Op != element->getOp())
+ if (kIntersect_SkClipOp != element->getOp() && kReplace_SkClipOp != element->getOp())
return false;
if (element->isInverseFilled()) {
// Part of 'rrect' could be trimmed off by the inverse-filled clip element
@@ -645,7 +645,7 @@
return false;
}
}
- if (SkCanvas::kReplace_Op == element->getOp()) {
+ if (kReplace_SkClipOp == element->getOp()) {
break;
}
element = iter.prev();
@@ -666,8 +666,8 @@
element->asPath(&operand);
}
- SkCanvas::ClipOp elementOp = element->getOp();
- if (elementOp == SkCanvas::kReplace_Op) {
+ SkClipOp elementOp = element->getOp();
+ if (elementOp == kReplace_SkClipOp) {
*path = operand;
} else {
Op(*path, operand, (SkPathOp)elementOp, path);
@@ -718,7 +718,7 @@
}
break;
}
- } else if (SkCanvas::kReplace_Op == element.getOp()) {
+ } else if (kReplace_SkClipOp == element.getOp()) {
this->restoreTo(fSaveCount - 1);
prior = (Element*) fDeque.back();
}
@@ -727,7 +727,7 @@
newElement->updateBoundAndGenID(prior);
}
-void SkClipStack::clipRRect(const SkRRect& rrect, const SkMatrix& matrix, SkCanvas::ClipOp op,
+void SkClipStack::clipRRect(const SkRRect& rrect, const SkMatrix& matrix, SkClipOp op,
bool doAA) {
SkRRect transformedRRect;
if (rrect.transform(matrix, &transformedRRect)) {
@@ -741,7 +741,7 @@
this->clipPath(path, matrix, op, doAA);
}
-void SkClipStack::clipRect(const SkRect& rect, const SkMatrix& matrix, SkCanvas::ClipOp op,
+void SkClipStack::clipRect(const SkRect& rect, const SkMatrix& matrix, SkClipOp op,
bool doAA) {
if (matrix.rectStaysRect()) {
SkRect devRect;
@@ -756,7 +756,7 @@
this->clipPath(path, matrix, op, doAA);
}
-void SkClipStack::clipPath(const SkPath& path, const SkMatrix& matrix, SkCanvas::ClipOp op,
+void SkClipStack::clipPath(const SkPath& path, const SkMatrix& matrix, SkClipOp op,
bool doAA) {
SkPath devPath;
path.transform(matrix, &devPath);
@@ -768,7 +768,7 @@
void SkClipStack::clipEmpty() {
Element* element = (Element*) fDeque.back();
- if (element && element->canBeIntersectedInPlace(fSaveCount, SkCanvas::kIntersect_Op)) {
+ if (element && element->canBeIntersectedInPlace(fSaveCount, kIntersect_SkClipOp)) {
element->setEmpty();
}
new (fDeque.push_back()) Element(fSaveCount);
@@ -794,7 +794,7 @@
return (const SkClipStack::Element*)fIter.prev();
}
-const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkCanvas::ClipOp op) {
+const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkClipOp op) {
if (nullptr == fStack) {
return nullptr;
@@ -879,13 +879,13 @@
back->getType() != SkClipStack::Element::kRRect_Type) {
return false;
}
- if (back->getOp() == SkCanvas::kReplace_Op) {
+ if (back->getOp() == kReplace_SkClipOp) {
*rrect = back->asRRect();
*aa = back->isAA();
return true;
}
- if (back->getOp() == SkCanvas::kIntersect_Op) {
+ if (back->getOp() == kIntersect_SkClipOp) {
SkRect backBounds;
if (!backBounds.intersect(bounds, back->asRRect().rect())) {
return false;
@@ -894,12 +894,12 @@
SkDeque::Iter iter(fDeque, SkDeque::Iter::kBack_IterStart);
SkAssertResult(static_cast<const Element*>(iter.prev()) == back);
while (const Element* prior = (const Element*)iter.prev()) {
- if ((prior->getOp() != SkCanvas::kIntersect_Op &&
- prior->getOp() != SkCanvas::kReplace_Op) ||
+ if ((prior->getOp() != kIntersect_SkClipOp &&
+ prior->getOp() != kReplace_SkClipOp) ||
!prior->contains(backBounds)) {
return false;
}
- if (prior->getOp() == SkCanvas::kReplace_Op) {
+ if (prior->getOp() == kReplace_SkClipOp) {
break;
}
}
@@ -951,12 +951,12 @@
"reverse-difference",
"replace",
};
- static_assert(0 == SkCanvas::kDifference_Op, "op_str");
- static_assert(1 == SkCanvas::kIntersect_Op, "op_str");
- static_assert(2 == SkCanvas::kUnion_Op, "op_str");
- static_assert(3 == SkCanvas::kXOR_Op, "op_str");
- static_assert(4 == SkCanvas::kReverseDifference_Op, "op_str");
- static_assert(5 == SkCanvas::kReplace_Op, "op_str");
+ static_assert(0 == kDifference_SkClipOp, "op_str");
+ static_assert(1 == kIntersect_SkClipOp, "op_str");
+ static_assert(2 == kUnion_SkClipOp, "op_str");
+ static_assert(3 == kXOR_SkClipOp, "op_str");
+ static_assert(4 == kReverseDifference_SkClipOp, "op_str");
+ static_assert(5 == kReplace_SkClipOp, "op_str");
static_assert(SK_ARRAY_COUNT(kOpStrings) == SkRegion::kOpCnt, "op_str");
SkDebugf("Type: %s, Op: %s, AA: %s, Save Count: %d\n", kTypeStrings[fType],
diff --git a/src/core/SkLiteDL.cpp b/src/core/SkLiteDL.cpp
index 3f6e54e..2548a81 100644
--- a/src/core/SkLiteDL.cpp
+++ b/src/core/SkLiteDL.cpp
@@ -149,34 +149,34 @@
struct ClipPath final : Op {
static const auto kType = Type::ClipPath;
- ClipPath(const SkPath& path, SkCanvas::ClipOp op, bool aa) : path(path), op(op), aa(aa) {}
- SkPath path;
- SkCanvas::ClipOp op;
- bool aa;
+ ClipPath(const SkPath& path, SkClipOp op, bool aa) : path(path), op(op), aa(aa) {}
+ SkPath path;
+ SkClipOp op;
+ bool aa;
void draw(SkCanvas* c, const SkMatrix&) { c->clipPath(path, op, aa); }
void makeThreadsafe() { make_threadsafe(&path, nullptr); }
};
struct ClipRect final : Op {
static const auto kType = Type::ClipRect;
- ClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool aa) : rect(rect), op(op), aa(aa) {}
- SkRect rect;
- SkCanvas::ClipOp op;
- bool aa;
+ ClipRect(const SkRect& rect, SkClipOp op, bool aa) : rect(rect), op(op), aa(aa) {}
+ SkRect rect;
+ SkClipOp op;
+ bool aa;
void draw(SkCanvas* c, const SkMatrix&) { c->clipRect(rect, op, aa); }
};
struct ClipRRect final : Op {
static const auto kType = Type::ClipRRect;
- ClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool aa) : rrect(rrect), op(op), aa(aa) {}
- SkRRect rrect;
- SkCanvas::ClipOp op;
- bool aa;
+ ClipRRect(const SkRRect& rrect, SkClipOp op, bool aa) : rrect(rrect), op(op), aa(aa) {}
+ SkRRect rrect;
+ SkClipOp op;
+ bool aa;
void draw(SkCanvas* c, const SkMatrix&) { c->clipRRect(rrect, op, aa); }
};
struct ClipRegion final : Op {
static const auto kType = Type::ClipRegion;
- ClipRegion(const SkRegion& region, SkCanvas::ClipOp op) : region(region), op(op) {}
- SkRegion region;
- SkCanvas::ClipOp op;
+ ClipRegion(const SkRegion& region, SkClipOp op) : region(region), op(op) {}
+ SkRegion region;
+ SkClipOp op;
void draw(SkCanvas* c, const SkMatrix&) { c->clipRegion(region, op); }
};
@@ -599,16 +599,16 @@
void SkLiteDL::translate(SkScalar dx, SkScalar dy) { this->push<Translate>(0, dx, dy); }
void SkLiteDL::translateZ(SkScalar dz) { this->push<TranslateZ>(0, dz); }
-void SkLiteDL::clipPath(const SkPath& path, SkCanvas::ClipOp op, bool aa) {
+void SkLiteDL::clipPath(const SkPath& path, SkClipOp op, bool aa) {
this->push<ClipPath>(0, path, op, aa);
}
-void SkLiteDL::clipRect(const SkRect& rect, SkCanvas::ClipOp op, bool aa) {
+void SkLiteDL::clipRect(const SkRect& rect, SkClipOp op, bool aa) {
this->push<ClipRect>(0, rect, op, aa);
}
-void SkLiteDL::clipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool aa) {
+void SkLiteDL::clipRRect(const SkRRect& rrect, SkClipOp op, bool aa) {
this->push<ClipRRect>(0, rrect, op, aa);
}
-void SkLiteDL::clipRegion(const SkRegion& region, SkCanvas::ClipOp op) {
+void SkLiteDL::clipRegion(const SkRegion& region, SkClipOp op) {
this->push<ClipRegion>(0, region, op);
}
diff --git a/src/core/SkLiteDL.h b/src/core/SkLiteDL.h
index 43988c0..330131f 100644
--- a/src/core/SkLiteDL.h
+++ b/src/core/SkLiteDL.h
@@ -43,10 +43,10 @@
void translate(SkScalar, SkScalar);
void translateZ(SkScalar);
- void clipPath (const SkPath&, SkCanvas::ClipOp, bool aa);
- void clipRect (const SkRect&, SkCanvas::ClipOp, bool aa);
- void clipRRect (const SkRRect&, SkCanvas::ClipOp, bool aa);
- void clipRegion(const SkRegion&, SkCanvas::ClipOp);
+ void clipPath (const SkPath&, SkClipOp, bool aa);
+ void clipRect (const SkRect&, SkClipOp, bool aa);
+ void clipRRect (const SkRRect&, SkClipOp, bool aa);
+ void clipRegion(const SkRegion&, SkClipOp);
void drawPaint (const SkPaint&);
void drawPath (const SkPath&, const SkPaint&);
diff --git a/src/core/SkLiteRecorder.cpp b/src/core/SkLiteRecorder.cpp
index b26547a..9f7ae39 100644
--- a/src/core/SkLiteRecorder.cpp
+++ b/src/core/SkLiteRecorder.cpp
@@ -40,19 +40,19 @@
void SkLiteRecorder::didSetMatrix(const SkMatrix& matrix) { fDL->setMatrix(matrix); }
void SkLiteRecorder::didTranslate(SkScalar dx, SkScalar dy) { fDL->translate(dx, dy); }
-void SkLiteRecorder::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle style) {
fDL->clipRect(rect, op, style==kSoft_ClipEdgeStyle);
this->INHERITED::onClipRect(rect, op, style);
}
-void SkLiteRecorder::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle style) {
fDL->clipRRect(rrect, op, style==kSoft_ClipEdgeStyle);
this->INHERITED::onClipRRect(rrect, op, style);
}
-void SkLiteRecorder::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle style) {
+void SkLiteRecorder::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle style) {
fDL->clipPath(path, op, style==kSoft_ClipEdgeStyle);
this->INHERITED::onClipPath(path, op, style);
}
-void SkLiteRecorder::onClipRegion(const SkRegion& region, ClipOp op) {
+void SkLiteRecorder::onClipRegion(const SkRegion& region, SkClipOp op) {
fDL->clipRegion(region, op);
this->INHERITED::onClipRegion(region, op);
}
diff --git a/src/core/SkLiteRecorder.h b/src/core/SkLiteRecorder.h
index 4ffd132..ad8f264 100644
--- a/src/core/SkLiteRecorder.h
+++ b/src/core/SkLiteRecorder.h
@@ -31,10 +31,10 @@
void didSetMatrix(const SkMatrix&) override;
void didTranslate(SkScalar, SkScalar) override;
- void onClipRect (const SkRect&, ClipOp, ClipEdgeStyle) override;
- void onClipRRect (const SkRRect&, ClipOp, ClipEdgeStyle) override;
- void onClipPath (const SkPath&, ClipOp, ClipEdgeStyle) override;
- void onClipRegion(const SkRegion&, ClipOp) override;
+ void onClipRect (const SkRect&, SkClipOp, ClipEdgeStyle) override;
+ void onClipRRect (const SkRRect&, SkClipOp, ClipEdgeStyle) override;
+ void onClipPath (const SkPath&, SkClipOp, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkClipOp) override;
void onDrawPaint (const SkPaint&) override;
void onDrawPath (const SkPath&, const SkPaint&) override;
diff --git a/src/core/SkPictureAnalyzer.cpp b/src/core/SkPictureAnalyzer.cpp
index a7a4d94..62c27e1 100644
--- a/src/core/SkPictureAnalyzer.cpp
+++ b/src/core/SkPictureAnalyzer.cpp
@@ -38,7 +38,7 @@
fNumSlowPaths += picture->numSlowPaths();
}
-void SkPictureGpuAnalyzer::analyzeClipPath(const SkPath& path, SkCanvas::ClipOp op, bool doAntiAlias) {
+void SkPictureGpuAnalyzer::analyzeClipPath(const SkPath& path, SkClipOp op, bool doAntiAlias) {
const SkRecords::ClipPath clipOp = {
SkIRect::MakeEmpty(), // Willie don't care.
path,
diff --git a/src/core/SkPictureFlat.h b/src/core/SkPictureFlat.h
index beb2dd8..d5263ca 100644
--- a/src/core/SkPictureFlat.h
+++ b/src/core/SkPictureFlat.h
@@ -128,13 +128,13 @@
// clipparams are packed in 5 bits
// doAA:1 | clipOp:4
-static inline uint32_t ClipParams_pack(SkCanvas::ClipOp op, bool doAA) {
+static inline uint32_t ClipParams_pack(SkClipOp op, bool doAA) {
unsigned doAABit = doAA ? 1 : 0;
return (doAABit << 4) | op;
}
-static inline SkCanvas::ClipOp ClipParams_unpackRegionOp(uint32_t packed) {
- return (SkCanvas::ClipOp)(packed & 0xF);
+static inline SkClipOp ClipParams_unpackRegionOp(uint32_t packed) {
+ return (SkClipOp)(packed & 0xF);
}
static inline bool ClipParams_unpackDoAA(uint32_t packed) {
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index 0b3dd0e..85e5c03 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -136,7 +136,7 @@
case CLIP_PATH: {
const SkPath& path = fPictureData->getPath(reader);
uint32_t packed = reader->readInt();
- SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
+ SkClipOp clipOp = ClipParams_unpackRegionOp(packed);
bool doAA = ClipParams_unpackDoAA(packed);
size_t offsetToRestore = reader->readInt();
BREAK_ON_READ_ERROR(reader);
@@ -151,7 +151,7 @@
SkRegion region;
reader->readRegion(®ion);
uint32_t packed = reader->readInt();
- SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
+ SkClipOp clipOp = ClipParams_unpackRegionOp(packed);
size_t offsetToRestore = reader->readInt();
BREAK_ON_READ_ERROR(reader);
@@ -165,7 +165,7 @@
SkRect rect;
reader->readRect(&rect);
uint32_t packed = reader->readInt();
- SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
+ SkClipOp clipOp = ClipParams_unpackRegionOp(packed);
bool doAA = ClipParams_unpackDoAA(packed);
size_t offsetToRestore = reader->readInt();
BREAK_ON_READ_ERROR(reader);
@@ -180,7 +180,7 @@
SkRRect rrect;
reader->readRRect(&rrect);
uint32_t packed = reader->readInt();
- SkCanvas::ClipOp clipOp = ClipParams_unpackRegionOp(packed);
+ SkClipOp clipOp = ClipParams_unpackRegionOp(packed);
bool doAA = ClipParams_unpackDoAA(packed);
size_t offsetToRestore = reader->readInt();
BREAK_ON_READ_ERROR(reader);
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 086eb8d..a0ac76d 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -230,18 +230,18 @@
#endif
}
-static bool clipOpExpands(SkCanvas::ClipOp op) {
+static bool clipOpExpands(SkClipOp op) {
switch (op) {
- case SkCanvas::kUnion_Op:
- case SkCanvas::kXOR_Op:
- case SkCanvas::kReverseDifference_Op:
- case SkCanvas::kReplace_Op:
+ case kUnion_SkClipOp:
+ case kXOR_SkClipOp:
+ case kReverseDifference_SkClipOp:
+ case kReplace_SkClipOp:
return true;
- case SkCanvas::kIntersect_Op:
- case SkCanvas::kDifference_Op:
+ case kIntersect_SkClipOp:
+ case kDifference_SkClipOp:
return false;
default:
- SkDEBUGFAIL("unknown region op");
+ SkDEBUGFAIL("unknown clipop");
return false;
}
}
@@ -279,7 +279,7 @@
this->restoreToCount(fInitialSaveCount);
}
-size_t SkPictureRecord::recordRestoreOffsetPlaceholder(ClipOp op) {
+size_t SkPictureRecord::recordRestoreOffsetPlaceholder(SkClipOp op) {
if (fRestoreOffsetStack.isEmpty()) {
return -1;
}
@@ -309,12 +309,12 @@
return offset;
}
-void SkPictureRecord::onClipRect(const SkRect& rect, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle) {
this->recordClipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle);
this->INHERITED::onClipRect(rect, op, edgeStyle);
}
-size_t SkPictureRecord::recordClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool doAA) {
+size_t SkPictureRecord::recordClipRect(const SkRect& rect, SkClipOp op, bool doAA) {
// id + rect + clip params
size_t size = 1 * kUInt32Size + sizeof(rect) + 1 * kUInt32Size;
// recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -331,12 +331,12 @@
return offset;
}
-void SkPictureRecord::onClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle) {
this->recordClipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
this->INHERITED::onClipRRect(rrect, op, edgeStyle);
}
-size_t SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA) {
+size_t SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkClipOp op, bool doAA) {
// op + rrect + clip params
size_t size = 1 * kUInt32Size + SkRRect::kSizeInMemory + 1 * kUInt32Size;
// recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -352,13 +352,13 @@
return offset;
}
-void SkPictureRecord::onClipPath(const SkPath& path, SkCanvas::ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkPictureRecord::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) {
int pathID = this->addPathToHeap(path);
this->recordClipPath(pathID, op, kSoft_ClipEdgeStyle == edgeStyle);
this->INHERITED::onClipPath(path, op, edgeStyle);
}
-size_t SkPictureRecord::recordClipPath(int pathID, SkCanvas::ClipOp op, bool doAA) {
+size_t SkPictureRecord::recordClipPath(int pathID, SkClipOp op, bool doAA) {
// op + path index + clip params
size_t size = 3 * kUInt32Size;
// recordRestoreOffsetPlaceholder doesn't always write an offset
@@ -374,12 +374,12 @@
return offset;
}
-void SkPictureRecord::onClipRegion(const SkRegion& region, ClipOp op) {
+void SkPictureRecord::onClipRegion(const SkRegion& region, SkClipOp op) {
this->recordClipRegion(region, op);
this->INHERITED::onClipRegion(region, op);
}
-size_t SkPictureRecord::recordClipRegion(const SkRegion& region, ClipOp op) {
+size_t SkPictureRecord::recordClipRegion(const SkRegion& region, SkClipOp op) {
// op + clip params + region
size_t size = 2 * kUInt32Size + region.writeToMemory(nullptr);
// recordRestoreOffsetPlaceholder doesn't always write an offset
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index ca858a6..9339d12 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -76,7 +76,7 @@
private:
void handleOptimization(int opt);
- size_t recordRestoreOffsetPlaceholder(SkCanvas::ClipOp);
+ size_t recordRestoreOffsetPlaceholder(SkClipOp);
void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
SkTDArray<int32_t> fRestoreOffsetStack;
@@ -204,10 +204,10 @@
const uint16_t indices[], int indexCount,
const SkPaint&) override;
- void onClipRect(const SkRect&, ClipOp, ClipEdgeStyle) override;
- void onClipRRect(const SkRRect&, ClipOp, ClipEdgeStyle) override;
- void onClipPath(const SkPath&, ClipOp, ClipEdgeStyle) override;
- void onClipRegion(const SkRegion&, ClipOp) override;
+ void onClipRect(const SkRect&, SkClipOp, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect&, SkClipOp, ClipEdgeStyle) override;
+ void onClipPath(const SkPath&, SkClipOp, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion&, SkClipOp) override;
void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
@@ -230,10 +230,10 @@
void recordConcat(const SkMatrix& matrix);
void recordTranslate(const SkMatrix& matrix);
void recordScale(const SkMatrix& matrix);
- size_t recordClipRect(const SkRect& rect, SkCanvas::ClipOp op, bool doAA);
- size_t recordClipRRect(const SkRRect& rrect, SkCanvas::ClipOp op, bool doAA);
- size_t recordClipPath(int pathID, SkCanvas::ClipOp op, bool doAA);
- size_t recordClipRegion(const SkRegion& region, SkCanvas::ClipOp op);
+ size_t recordClipRect(const SkRect& rect, SkClipOp op, bool doAA);
+ size_t recordClipRRect(const SkRRect& rrect, SkClipOp op, bool doAA);
+ size_t recordClipPath(int pathID, SkClipOp op, bool doAA);
+ size_t recordClipRegion(const SkRegion& region, SkClipOp op);
void recordSave();
void recordSaveLayer(const SaveLayerRec&);
void recordRestore(bool fillInSkips = true);
diff --git a/src/core/SkRecorder.cpp b/src/core/SkRecorder.cpp
index 4c56d99..f4c6b50 100644
--- a/src/core/SkRecorder.cpp
+++ b/src/core/SkRecorder.cpp
@@ -404,25 +404,25 @@
#endif
}
-void SkRecorder::onClipRect(const SkRect& rect, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle) {
INHERITED(onClipRect, rect, op, edgeStyle);
SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
APPEND(ClipRect, this->devBounds(), rect, opAA);
}
-void SkRecorder::onClipRRect(const SkRRect& rrect, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle) {
INHERITED(onClipRRect, rrect, op, edgeStyle);
SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
APPEND(ClipRRect, this->devBounds(), rrect, opAA);
}
-void SkRecorder::onClipPath(const SkPath& path, ClipOp op, ClipEdgeStyle edgeStyle) {
+void SkRecorder::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) {
INHERITED(onClipPath, path, op, edgeStyle);
SkRecords::ClipOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle);
APPEND(ClipPath, this->devBounds(), path, opAA);
}
-void SkRecorder::onClipRegion(const SkRegion& deviceRgn, ClipOp op) {
+void SkRecorder::onClipRegion(const SkRegion& deviceRgn, SkClipOp op) {
INHERITED(onClipRegion, deviceRgn, op);
APPEND(ClipRegion, this->devBounds(), deviceRgn, op);
}
diff --git a/src/core/SkRecorder.h b/src/core/SkRecorder.h
index c93ee63..c810076 100644
--- a/src/core/SkRecorder.h
+++ b/src/core/SkRecorder.h
@@ -132,10 +132,10 @@
void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
int count, SkBlendMode, const SkRect* cull, const SkPaint*) override;
- void onClipRect(const SkRect& rect, ClipOp, ClipEdgeStyle) override;
- void onClipRRect(const SkRRect& rrect, ClipOp, ClipEdgeStyle) override;
- void onClipPath(const SkPath& path, ClipOp, ClipEdgeStyle) override;
- void onClipRegion(const SkRegion& deviceRgn, ClipOp) override;
+ void onClipRect(const SkRect& rect, SkClipOp, ClipEdgeStyle) override;
+ void onClipRRect(const SkRRect& rrect, SkClipOp, ClipEdgeStyle) override;
+ void onClipPath(const SkPath& path, SkClipOp, ClipEdgeStyle) override;
+ void onClipRegion(const SkRegion& deviceRgn, SkClipOp) override;
void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;