Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SkClipOp is now an enum class

Browse Source 
Change-Id: If423dd013a264162ae0b7674a0eeef34bc2cdaae
This commit is contained in:
Mike Reed
2016-12-14 10:29:54 -05:00
parent 9ed3a080e8
commit 6c67f1d045
19 changed files with 55 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
core/jni/android_graphics_Canvas.cpp
View File

@@ -185,12 +185,12 @@ static jboolean quickRejectPath(JNIEnv* env, jobject, jlong canvasHandle, jlong
// SkRegion::Op and SkClipOp are numerically identical, so we can freely cast
// from one to the other (though SkClipOp is destined to become a strict subset)
static_assert(SkRegion::kDifference_Op == static_cast<SkRegion::Op>(kDifference_SkClipOp), "");
static_assert(SkRegion::kIntersect_Op == static_cast<SkRegion::Op>(kIntersect_SkClipOp), "");
static_assert(SkRegion::kUnion_Op == static_cast<SkRegion::Op>(kUnion_SkClipOp), "");
static_assert(SkRegion::kXOR_Op == static_cast<SkRegion::Op>(kXOR_SkClipOp), "");
static_assert(SkRegion::kReverseDifference_Op == static_cast<SkRegion::Op>(kReverseDifference_SkClipOp), "");
static_assert(SkRegion::kReplace_Op == static_cast<SkRegion::Op>(kReplace_SkClipOp), "");
static_assert(SkRegion::kDifference_Op == static_cast<SkRegion::Op>(SkClipOp::kDifference), "");
static_assert(SkRegion::kIntersect_Op == static_cast<SkRegion::Op>(SkClipOp::kIntersect), "");
static_assert(SkRegion::kUnion_Op == static_cast<SkRegion::Op>(SkClipOp::kUnion), "");
static_assert(SkRegion::kXOR_Op == static_cast<SkRegion::Op>(SkClipOp::kXOR), "");
static_assert(SkRegion::kReverseDifference_Op == static_cast<SkRegion::Op>(SkClipOp::kReverseDifference), "");
static_assert(SkRegion::kReplace_Op == static_cast<SkRegion::Op>(SkClipOp::kReplace), "");
static SkClipOp opHandleToClipOp(jint opHandle) {
// The opHandle is defined in Canvas.java to be Region::Op

2
core/jni/android_view_GraphicBuffer.cpp
View File

@@ -197,7 +197,7 @@ static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject,
Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvas);
nativeCanvas->setBitmap(bitmap);
nativeCanvas->clipRect(rect.left, rect.top, rect.right, rect.bottom,
kIntersect_SkClipOp);
SkClipOp::kIntersect);
if (dirtyRect) {
INVOKEV(dirtyRect, gRectClassInfo.set,

2
core/jni/android_view_Surface.cpp
View File

@@ -339,7 +339,7 @@ static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
if (dirtyRectPtr) {
nativeCanvas->clipRect(dirtyRect.left, dirtyRect.top,
dirtyRect.right, dirtyRect.bottom, kIntersect_SkClipOp);
dirtyRect.right, dirtyRect.bottom, SkClipOp::kIntersect);
}
if (dirtyRectObj) {

2
core/jni/android_view_TextureView.cpp
View File

@@ -167,7 +167,7 @@ static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject,
Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvas);
nativeCanvas->setBitmap(bitmap);
nativeCanvas->clipRect(rect.left, rect.top, rect.right, rect.bottom,
kIntersect_SkClipOp);
SkClipOp::kIntersect);
if (dirtyRect) {
INVOKEV(dirtyRect, gRectClassInfo.set,

2
libs/hwui/CanvasState.cpp
View File

@@ -225,7 +225,7 @@ void CanvasState::setClippingOutline(LinearAllocator& allocator, const Outline*
bool outlineIsRounded = MathUtils::isPositive(radius);
if (!outlineIsRounded || currentTransform()->isSimple()) {
// TODO: consider storing this rect separately, so that this can't be replaced with clip ops
clipRect(bounds.left, bounds.top, bounds.right, bounds.bottom, kIntersect_SkClipOp);
clipRect(bounds.left, bounds.top, bounds.right, bounds.bottom, SkClipOp::kIntersect);
}
if (outlineIsRounded) {
setClippingRoundRect(allocator, bounds, radius, false);

4
libs/hwui/FrameBuilder.cpp
View File

@@ -120,7 +120,7 @@ void FrameBuilder::deferRenderNode(float tx, float ty, Rect clipRect, RenderNode
mCanvasState.save(SaveFlags::MatrixClip);
mCanvasState.translate(tx, ty);
mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
kIntersect_SkClipOp);
SkClipOp::kIntersect);
deferNodePropsAndOps(renderNode);
mCanvasState.restore();
}
@@ -262,7 +262,7 @@ void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
Rect clipRect;
properties.getClippingRectForFlags(clipFlags, &clipRect);
mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
kIntersect_SkClipOp);
SkClipOp::kIntersect);
}
if (properties.getRevealClip().willClip()) {

2
libs/hwui/Snapshot.h
View File

@@ -115,7 +115,7 @@ public:
* the specified operation. The specified rectangle is considered
* already transformed.
*/
void clipTransformed(const Rect& r, SkClipOp op = kIntersect_SkClipOp);
void clipTransformed(const Rect& r, SkClipOp op = SkClipOp::kIntersect);
/**
* Modifies the current clip with the specified region and operation.

4
libs/hwui/pipeline/skia/RenderNodeDrawable.cpp
View File

@@ -68,7 +68,7 @@ static void clipOutline(const Outline& outline, SkCanvas* canvas, const SkRect*
if (pendingClip && !pendingClip->contains(rect)) {
canvas->clipRect(*pendingClip);
}
canvas->clipRRect(SkRRect::MakeRectXY(rect, radius, radius), kIntersect_SkClipOp, true);
canvas->clipRRect(SkRRect::MakeRectXY(rect, radius, radius), SkClipOp::kIntersect, true);
} else {
if (pendingClip) {
(void)rect.intersect(*pendingClip);
@@ -263,7 +263,7 @@ void RenderNodeDrawable::setViewProperties(const RenderProperties& properties, S
}
if (properties.getRevealClip().willClip()) {
canvas->clipPath(*properties.getRevealClip().getPath(), kIntersect_SkClipOp, true);
canvas->clipPath(*properties.getRevealClip().getPath(), SkClipOp::kIntersect, true);
} else if (properties.getOutline().willClip()) {
clipOutline(properties.getOutline(), canvas, pendingClip);
pendingClip = nullptr;

4
libs/hwui/pipeline/skia/SkiaPipeline.cpp
View File

@@ -100,7 +100,7 @@ void SkiaPipeline::renderLayersImpl(const LayerUpdateQueue& layers, bool opaque)
int saveCount = layerCanvas->save();
SkASSERT(saveCount == 1);
layerCanvas->clipRect(layerDamage.toSkRect(), kReplace_SkClipOp);
layerCanvas->clipRect(layerDamage.toSkRect(), SkClipOp::kReplace);
auto savedLightCenter = mLightCenter;
// map current light center into RenderNode's coordinate space
@@ -234,7 +234,7 @@ void SkiaPipeline::renderFrameImpl(const LayerUpdateQueue& layers, const SkRect&
const std::vector<sp<RenderNode>>& nodes, bool opaque, const Rect &contentDrawBounds,
SkCanvas* canvas) {
canvas->clipRect(clip, kReplace_SkClipOp);
canvas->clipRect(clip, SkClipOp::kReplace);
if (!opaque) {
canvas->clear(SK_ColorTRANSPARENT);

6
libs/hwui/tests/common/scenes/ClippingAnimation.cpp
View File

@@ -34,11 +34,11 @@ public:
[](RenderProperties& props, Canvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
{
canvas.clipRect(0, 0, 200, 200, kIntersect_SkClipOp);
canvas.clipRect(0, 0, 200, 200, SkClipOp::kIntersect);
canvas.translate(100, 100);
canvas.rotate(45);
canvas.translate(-100, -100);
canvas.clipRect(0, 0, 200, 200, kIntersect_SkClipOp);
canvas.clipRect(0, 0, 200, 200, SkClipOp::kIntersect);
canvas.drawColor(Color::Blue_500, SkBlendMode::kSrcOver);
}
canvas.restore();
@@ -47,7 +47,7 @@ public:
{
SkPath clipCircle;
clipCircle.addCircle(100, 300, 100);
canvas.clipPath(&clipCircle, kIntersect_SkClipOp);
canvas.clipPath(&clipCircle, SkClipOp::kIntersect);
canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
}
canvas.restore();

2
libs/hwui/tests/common/scenes/SaveLayerAnimation.cpp
View File

@@ -36,7 +36,7 @@ public:
// nested clipped saveLayers
canvas.saveLayerAlpha(0, 0, 400, 400, 200, SaveFlags::ClipToLayer);
canvas.drawColor(Color::Green_700, SkBlendMode::kSrcOver);
canvas.clipRect(50, 50, 350, 350, kIntersect_SkClipOp);
canvas.clipRect(50, 50, 350, 350, SkClipOp::kIntersect);
canvas.saveLayerAlpha(100, 100, 300, 300, 128, SaveFlags::ClipToLayer);
canvas.drawColor(Color::Blue_500, SkBlendMode::kSrcOver);
canvas.restore();

2
libs/hwui/tests/common/scenes/ShapeAnimation.cpp
View File

@@ -82,7 +82,7 @@ public:
int middleCount = canvas.save(SaveFlags::MatrixClip);
for (auto op : ops) {
int innerCount = canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(0, 0, cellSize, cellSize, kIntersect_SkClipOp);
canvas.clipRect(0, 0, cellSize, cellSize, SkClipOp::kIntersect);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
op(canvas, cellSize, paint);
canvas.restoreToCount(innerCount);

2
libs/hwui/tests/microbench/DisplayListCanvasBench.cpp
View File

@@ -177,7 +177,7 @@ void BM_DisplayListCanvas_basicViewGroupDraw(benchmark::State& benchState) {
// Clip to padding
// Can expect ~25% of views to have clip to padding with a non-null padding
int clipRestoreCount = canvas->save(SaveFlags::MatrixClip);
canvas->clipRect(1, 1, 199, 199, kIntersect_SkClipOp);
canvas->clipRect(1, 1, 199, 199, SkClipOp::kIntersect);
canvas->insertReorderBarrier(true);

16
libs/hwui/tests/unit/CanvasStateTests.cpp
View File

@@ -68,13 +68,13 @@ TEST(CanvasState, simpleClipping) {
state.initializeSaveStack(200, 200,
0, 0, 200, 200, Vector3());
state.clipRect(0, 0, 100, 100, kIntersect_SkClipOp);
state.clipRect(0, 0, 100, 100, SkClipOp::kIntersect);
ASSERT_EQ(state.getRenderTargetClipBounds(), Rect(100, 100));
state.clipRect(10, 10, 200, 200, kIntersect_SkClipOp);
state.clipRect(10, 10, 200, 200, SkClipOp::kIntersect);
ASSERT_EQ(state.getRenderTargetClipBounds(), Rect(10, 10, 100, 100));
state.clipRect(50, 50, 150, 150, kReplace_SkClipOp);
state.clipRect(50, 50, 150, 150, SkClipOp::kReplace);
ASSERT_EQ(state.getRenderTargetClipBounds(), Rect(50, 50, 150, 150));
}
@@ -88,7 +88,7 @@ TEST(CanvasState, complexClipping) {
// rotated clip causes complex clip
state.rotate(10);
EXPECT_TRUE(state.clipIsSimple());
state.clipRect(0, 0, 200, 200, kIntersect_SkClipOp);
state.clipRect(0, 0, 200, 200, SkClipOp::kIntersect);
EXPECT_FALSE(state.clipIsSimple());
}
state.restore();
@@ -97,7 +97,7 @@ TEST(CanvasState, complexClipping) {
{
// subtracted clip causes complex clip
EXPECT_TRUE(state.clipIsSimple());
state.clipRect(50, 50, 150, 150, kDifference_SkClipOp);
state.clipRect(50, 50, 150, 150, SkClipOp::kDifference);
EXPECT_FALSE(state.clipIsSimple());
}
state.restore();
@@ -108,7 +108,7 @@ TEST(CanvasState, complexClipping) {
SkPath path;
path.addOval(SkRect::MakeWH(200, 200));
EXPECT_TRUE(state.clipIsSimple());
state.clipPath(&path, kDifference_SkClipOp);
state.clipPath(&path, SkClipOp::kDifference);
EXPECT_FALSE(state.clipIsSimple());
}
state.restore();
@@ -121,7 +121,7 @@ TEST(CanvasState, saveAndRestore) {
state.save(SaveFlags::Clip);
{
state.clipRect(0, 0, 10, 10, kIntersect_SkClipOp);
state.clipRect(0, 0, 10, 10, SkClipOp::kIntersect);
ASSERT_EQ(state.getRenderTargetClipBounds(), Rect(10, 10));
}
state.restore();
@@ -145,7 +145,7 @@ TEST(CanvasState, saveAndRestoreButNotTooMuch) {
state.save(SaveFlags::Matrix); // NOTE: clip not saved
{
state.clipRect(0, 0, 10, 10, kIntersect_SkClipOp);
state.clipRect(0, 0, 10, 10, SkClipOp::kIntersect);
ASSERT_EQ(state.getRenderTargetClipBounds(), Rect(10, 10));
}
state.restore();

22
libs/hwui/tests/unit/FrameBuilderTests.cpp
View File

@@ -174,7 +174,7 @@ RENDERTHREAD_TEST(FrameBuilder, simpleRejection) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(200, 200, 400, 400, kIntersect_SkClipOp); // intersection should be empty
canvas.clipRect(200, 200, 400, 400, SkClipOp::kIntersect); // intersection should be empty
canvas.drawRect(0, 0, 400, 400, SkPaint());
canvas.restore();
});
@@ -453,19 +453,19 @@ RENDERTHREAD_TEST(FrameBuilder, clippedMerging) {
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(20, 20));
// left side clipped (to inset left half)
canvas.clipRect(10, 0, 50, 100, kReplace_SkClipOp);
canvas.clipRect(10, 0, 50, 100, SkClipOp::kReplace);
canvas.drawBitmap(*bitmap, 0, 40, nullptr);
// top side clipped (to inset top half)
canvas.clipRect(0, 10, 100, 50, kReplace_SkClipOp);
canvas.clipRect(0, 10, 100, 50, SkClipOp::kReplace);
canvas.drawBitmap(*bitmap, 40, 0, nullptr);
// right side clipped (to inset right half)
canvas.clipRect(50, 0, 90, 100, kReplace_SkClipOp);
canvas.clipRect(50, 0, 90, 100, SkClipOp::kReplace);
canvas.drawBitmap(*bitmap, 80, 40, nullptr);
// bottom not clipped, just abutting (inset bottom half)
canvas.clipRect(0, 50, 100, 90, kReplace_SkClipOp);
canvas.clipRect(0, 50, 100, 90, SkClipOp::kReplace);
canvas.drawBitmap(*bitmap, 40, 70, nullptr);
});
@@ -488,7 +488,7 @@ RENDERTHREAD_TEST(FrameBuilder, regionClipStopsMerge) {
SkPath path;
path.addCircle(200, 200, 200, SkPath::kCW_Direction);
canvas.save(SaveFlags::MatrixClip);
canvas.clipPath(&path, kIntersect_SkClipOp);
canvas.clipPath(&path, SkClipOp::kIntersect);
SkPaint paint;
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
paint.setAntiAlias(true);
@@ -649,7 +649,7 @@ RENDERTHREAD_TEST(FrameBuilder, textureLayer_clipLocalMatrix) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[&layerUpdater](RenderProperties& props, RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(50, 50, 150, 150, kIntersect_SkClipOp);
canvas.clipRect(50, 50, 150, 150, SkClipOp::kIntersect);
canvas.drawLayer(layerUpdater.get());
canvas.restore();
});
@@ -973,7 +973,7 @@ RENDERTHREAD_TEST(FrameBuilder, saveLayer_contentRejection) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(200, 200, 400, 400, kIntersect_SkClipOp);
canvas.clipRect(200, 200, 400, 400, SkClipOp::kIntersect);
canvas.saveLayerAlpha(200, 200, 400, 400, 128, SaveFlags::ClipToLayer);
// draw within save layer may still be recorded, but shouldn't be drawn
@@ -1781,7 +1781,7 @@ RENDERTHREAD_TEST(FrameBuilder, projectionChildScroll) {
auto child = TestUtils::createNode<RecordingCanvas>(0, 0, 400, 400,
[&projectingRipple](RenderProperties& properties, RecordingCanvas& canvas) {
// Record time clip will be ignored by projectee
canvas.clipRect(100, 100, 300, 300, kIntersect_SkClipOp);
canvas.clipRect(100, 100, 300, 300, SkClipOp::kIntersect);
canvas.translate(-scrollX, -scrollY); // Apply scroll (note: bg undoes this internally)
canvas.drawRenderNode(projectingRipple.get());
@@ -1993,7 +1993,7 @@ RENDERTHREAD_TEST(FrameBuilder, shadowClipping) {
[](RenderProperties& props, RecordingCanvas& canvas) {
// Apply a clip before the reorder barrier/shadow casting child is drawn.
// This clip must be applied to the shadow cast by the child.
canvas.clipRect(25, 25, 75, 75, kIntersect_SkClipOp);
canvas.clipRect(25, 25, 75, 75, SkClipOp::kIntersect);
canvas.insertReorderBarrier(true);
canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get());
});
@@ -2252,7 +2252,7 @@ RENDERTHREAD_TEST(FrameBuilder, clip_replace) {
};
auto node = TestUtils::createNode<RecordingCanvas>(20, 20, 30, 30,
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.clipRect(0, -20, 10, 30, kReplace_SkClipOp);
canvas.clipRect(0, -20, 10, 30, SkClipOp::kReplace);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
});

20
libs/hwui/tests/unit/RecordingCanvasTests.cpp
View File

@@ -58,7 +58,7 @@ TEST(RecordingCanvas, emptyPlayback) {
TEST(RecordingCanvas, clipRect) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(100, 100, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(0, 0, 100, 100, kIntersect_SkClipOp);
canvas.clipRect(0, 0, 100, 100, SkClipOp::kIntersect);
canvas.drawRect(0, 0, 50, 50, SkPaint());
canvas.drawRect(50, 50, 100, 100, SkPaint());
canvas.restore();
@@ -74,8 +74,8 @@ TEST(RecordingCanvas, clipRect) {
TEST(RecordingCanvas, emptyClipRect) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(0, 0, 100, 100, kIntersect_SkClipOp);
canvas.clipRect(100, 100, 200, 200, kIntersect_SkClipOp);
canvas.clipRect(0, 0, 100, 100, SkClipOp::kIntersect);
canvas.clipRect(100, 100, 200, 200, SkClipOp::kIntersect);
canvas.drawRect(0, 0, 50, 50, SkPaint()); // rejected at record time
canvas.restore();
});
@@ -441,7 +441,7 @@ TEST(RecordingCanvas, saveLayer_simpleUnclipped) {
TEST(RecordingCanvas, saveLayer_addClipFlag) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(10, 20, 190, 180, kIntersect_SkClipOp);
canvas.clipRect(10, 20, 190, 180, SkClipOp::kIntersect);
canvas.saveLayerAlpha(10, 20, 190, 180, 128, (SaveFlags::Flags)0); // unclipped
canvas.drawRect(10, 20, 190, 180, SkPaint());
canvas.restore();
@@ -460,7 +460,7 @@ TEST(RecordingCanvas, saveLayer_addClipFlag) {
TEST(RecordingCanvas, saveLayer_viewportCrop) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) {
// shouldn't matter, since saveLayer will clip to its bounds
canvas.clipRect(-1000, -1000, 1000, 1000, kReplace_SkClipOp);
canvas.clipRect(-1000, -1000, 1000, 1000, SkClipOp::kReplace);
canvas.saveLayerAlpha(100, 100, 300, 300, 128, SaveFlags::ClipToLayer);
canvas.drawRect(0, 0, 400, 400, SkPaint());
@@ -550,7 +550,7 @@ TEST(RecordingCanvas, saveLayer_rejectBegin) {
canvas.save(SaveFlags::MatrixClip);
canvas.translate(0, -20); // avoid identity case
// empty clip rect should force layer + contents to be rejected
canvas.clipRect(0, -20, 200, -20, kIntersect_SkClipOp);
canvas.clipRect(0, -20, 200, -20, SkClipOp::kIntersect);
canvas.saveLayerAlpha(0, 0, 200, 200, 128, SaveFlags::ClipToLayer);
canvas.drawRect(0, 0, 200, 200, SkPaint());
canvas.restore();
@@ -569,7 +569,7 @@ TEST(RecordingCanvas, drawRenderNode_rejection) {
});
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [&child](RecordingCanvas& canvas) {
canvas.clipRect(0, 0, 0, 0, kIntersect_SkClipOp); // empty clip, reject node
canvas.clipRect(0, 0, 0, 0, SkClipOp::kIntersect); // empty clip, reject node
canvas.drawRenderNode(child.get()); // shouldn't crash when rejecting node...
});
ASSERT_TRUE(dl->isEmpty());
@@ -622,7 +622,7 @@ TEST(RecordingCanvas, firstClipWillReplace) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
// since no explicit clip set on canvas, this should be the one observed on op:
canvas.clipRect(-100, -100, 300, 300, kIntersect_SkClipOp);
canvas.clipRect(-100, -100, 300, 300, SkClipOp::kIntersect);
SkPaint paint;
paint.setColor(SK_ColorWHITE);
@@ -638,7 +638,7 @@ TEST(RecordingCanvas, firstClipWillReplace) {
TEST(RecordingCanvas, replaceClipIntersectWithRoot) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(100, 100, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(-10, -10, 110, 110, kReplace_SkClipOp);
canvas.clipRect(-10, -10, 110, 110, SkClipOp::kReplace);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
canvas.restore();
});
@@ -676,7 +676,7 @@ TEST(RecordingCanvas, insertReorderBarrier_clip) {
canvas.drawRect(0, 0, 400, 400, SkPaint());
// second chunk: no recorded clip, since inorder region
canvas.clipRect(0, 0, 200, 200, kIntersect_SkClipOp);
canvas.clipRect(0, 0, 200, 200, SkClipOp::kIntersect);
canvas.insertReorderBarrier(false);
canvas.drawRect(0, 0, 400, 400, SkPaint());

2
libs/hwui/tests/unit/RenderNodeDrawableTests.cpp
View File

@@ -455,7 +455,7 @@ RENDERTHREAD_TEST(RenderNodeDrawable, projectionChildScroll) {
auto child = TestUtils::createSkiaNode(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
[&projectingRipple](RenderProperties& properties, SkiaRecordingCanvas& canvas) {
// Record time clip will be ignored by projectee
canvas.clipRect(100, 100, 300, 300, kIntersect_SkClipOp);
canvas.clipRect(100, 100, 300, 300, SkClipOp::kIntersect);
canvas.translate(-SCROLL_X, -SCROLL_Y); // Apply scroll (note: bg undoes this internally)
canvas.drawRenderNode(projectingRipple.get());

2
libs/hwui/tests/unit/SkiaPipelineTests.cpp
View File

@@ -339,7 +339,7 @@ RENDERTHREAD_TEST(SkiaPipeline, clip_replace) {
std::vector<sp<RenderNode>> nodes;
nodes.push_back(TestUtils::createSkiaNode(20, 20, 30, 30,
[](RenderProperties& props, SkiaRecordingCanvas& canvas) {
canvas.clipRect(0, -20, 10, 30, kReplace_SkClipOp);
canvas.clipRect(0, -20, 10, 30, SkClipOp::kReplace);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
}));

2
libs/hwui/utils/TestWindowContext.cpp
View File

@@ -93,7 +93,7 @@ public:
SkCanvas* prepareToDraw() {
//mCanvas->reset(mSize.width(), mSize.height());
mCanvas->clipRect(0, 0, mSize.width(), mSize.height(), kReplace_SkClipOp);
mCanvas->clipRect(0, 0, mSize.width(), mSize.height(), SkClipOp::kReplace);
return mCanvas->asSkCanvas();
}