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

use SkBlendMode instead of SkXfermode

Browse Source 
use sk_sp versions of paint setters/getters

Change-Id: I86591a0a8ec92e6039776cbf00424ea24f585b28
This commit is contained in:
Mike Reed
2016-10-07 15:59:20 -04:00
parent ccbc5c1830
commit 260ab72648
59 changed files with 276 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/jni/android/graphics/BitmapFactory.cpp
View File

@@ -497,7 +497,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
// kSrc_Mode instructs us to overwrite the uninitialized pixels in
// outputBitmap. Otherwise we would blend by default, which is not
// what we want.
paint.setXfermodeMode(SkXfermode::kSrc_Mode);
paint.setBlendMode(SkBlendMode::kSrc);
paint.setFilterQuality(kLow_SkFilterQuality); // bilinear filtering
SkCanvas canvas(outputBitmap);

11
core/jni/android/graphics/ColorFilter.cpp
View File

@@ -21,7 +21,6 @@
#include "SkColorFilter.h"
#include "SkColorMatrixFilter.h"
#include "SkXfermode.h"
#include <Caches.h>
@@ -33,16 +32,16 @@ class SkColorFilterGlue {
public:
static void finalizer(JNIEnv* env, jobject clazz, jlong skFilterHandle) {
SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
if (filter) SkSafeUnref(filter);
SkSafeUnref(filter);
}
static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor, jint modeHandle) {
SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(modeHandle);
return reinterpret_cast<jlong>(SkColorFilter::CreateModeFilter(srcColor, mode));
SkBlendMode mode = static_cast<SkBlendMode>(modeHandle);
return reinterpret_cast<jlong>(SkColorFilter::MakeModeFilter(srcColor, mode).release());
}
static jlong CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) {
return reinterpret_cast<jlong>(SkColorMatrixFilter::CreateLightingFilter(mul, add));
return reinterpret_cast<jlong>(SkColorMatrixFilter::MakeLightingFilter(mul, add).release());
}
static jlong CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) {
@@ -50,7 +49,7 @@ public:
const float* src = autoArray.ptr();
#ifdef SK_SCALAR_IS_FLOAT
return reinterpret_cast<jlong>(SkColorMatrixFilter::Create(src));
return reinterpret_cast<jlong>(SkColorFilter::MakeMatrixFilterRowMajor255(src).release());
#else
SkASSERT(false);
#endif

2
core/jni/android/graphics/GraphicsJNI.h
View File

@@ -53,7 +53,7 @@ public:
// Given the 'native' long held by the Rasterizer.java object, return a
// ref to its SkRasterizer* (or NULL).
static SkRasterizer* refNativeRasterizer(jlong rasterizerHandle);
static sk_sp<SkRasterizer> refNativeRasterizer(jlong rasterizerHandle);
/*
* LegacyBitmapConfig is the old enum in Skia that matched the enum int values

6
core/jni/android/graphics/MaskFilter.cpp
View File

@@ -23,7 +23,7 @@ public:
static jlong createBlur(JNIEnv* env, jobject, jfloat radius, jint blurStyle) {
SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
SkMaskFilter* filter = SkBlurMaskFilter::Create((SkBlurStyle)blurStyle, sigma);
SkMaskFilter* filter = SkBlurMaskFilter::Make((SkBlurStyle)blurStyle, sigma).release();
ThrowIAE_IfNull(env, filter);
return reinterpret_cast<jlong>(filter);
}
@@ -38,8 +38,8 @@ public:
}
SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
SkMaskFilter* filter = SkBlurMaskFilter::CreateEmboss(sigma,
direction, ambient, specular);
SkMaskFilter* filter = SkBlurMaskFilter::MakeEmboss(sigma,
direction, ambient, specular).release();
ThrowIAE_IfNull(env, filter);
return reinterpret_cast<jlong>(filter);
}

59
core/jni/android/graphics/Paint.cpp
View File

@@ -29,6 +29,7 @@
#include "SkColorFilter.h"
#include "SkMaskFilter.h"
#include "SkPath.h"
#include "SkPathEffect.h"
#include "SkRasterizer.h"
#include "SkShader.h"
#include "SkXfermode.h"
@@ -791,51 +792,55 @@ namespace PaintGlue {
static jlong setShader(jlong objHandle, jlong shaderHandle) {
Paint* obj = reinterpret_cast<Paint*>(objHandle);
SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
return reinterpret_cast<jlong>(obj->setShader(shader));
obj->setShader(sk_ref_sp(shader));
return reinterpret_cast<jlong>(obj->getShader());
}
static jlong setColorFilter(jlong objHandle, jlong filterHandle) {
Paint* obj = reinterpret_cast<Paint *>(objHandle);
SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(filterHandle);
return reinterpret_cast<jlong>(obj->setColorFilter(filter));
obj->setColorFilter(sk_ref_sp(filter));
return reinterpret_cast<jlong>(obj->getColorFilter());
}
static void setXfermode(jlong paintHandle, jint xfermodeHandle) {
// validate that the Java enum values match our expectations
static_assert(0 == SkXfermode::kClear_Mode, "xfermode_mismatch");
static_assert(1 == SkXfermode::kSrc_Mode, "xfermode_mismatch");
static_assert(2 == SkXfermode::kDst_Mode, "xfermode_mismatch");
static_assert(3 == SkXfermode::kSrcOver_Mode, "xfermode_mismatch");
static_assert(4 == SkXfermode::kDstOver_Mode, "xfermode_mismatch");
static_assert(5 == SkXfermode::kSrcIn_Mode, "xfermode_mismatch");
static_assert(6 == SkXfermode::kDstIn_Mode, "xfermode_mismatch");
static_assert(7 == SkXfermode::kSrcOut_Mode, "xfermode_mismatch");
static_assert(8 == SkXfermode::kDstOut_Mode, "xfermode_mismatch");
static_assert(9 == SkXfermode::kSrcATop_Mode, "xfermode_mismatch");
static_assert(10 == SkXfermode::kDstATop_Mode, "xfermode_mismatch");
static_assert(11 == SkXfermode::kXor_Mode, "xfermode_mismatch");
static_assert(16 == SkXfermode::kDarken_Mode, "xfermode_mismatch");
static_assert(17 == SkXfermode::kLighten_Mode, "xfermode_mismatch");
static_assert(13 == SkXfermode::kModulate_Mode, "xfermode_mismatch");
static_assert(14 == SkXfermode::kScreen_Mode, "xfermode_mismatch");
static_assert(12 == SkXfermode::kPlus_Mode, "xfermode_mismatch");
static_assert(15 == SkXfermode::kOverlay_Mode, "xfermode_mismatch");
static_assert(0 == static_cast<int>(SkBlendMode::kClear), "xfermode_mismatch");
static_assert(1 == static_cast<int>(SkBlendMode::kSrc), "xfermode_mismatch");
static_assert(2 == static_cast<int>(SkBlendMode::kDst), "xfermode_mismatch");
static_assert(3 == static_cast<int>(SkBlendMode::kSrcOver), "xfermode_mismatch");
static_assert(4 == static_cast<int>(SkBlendMode::kDstOver), "xfermode_mismatch");
static_assert(5 == static_cast<int>(SkBlendMode::kSrcIn), "xfermode_mismatch");
static_assert(6 == static_cast<int>(SkBlendMode::kDstIn), "xfermode_mismatch");
static_assert(7 == static_cast<int>(SkBlendMode::kSrcOut), "xfermode_mismatch");
static_assert(8 == static_cast<int>(SkBlendMode::kDstOut), "xfermode_mismatch");
static_assert(9 == static_cast<int>(SkBlendMode::kSrcATop), "xfermode_mismatch");
static_assert(10 == static_cast<int>(SkBlendMode::kDstATop), "xfermode_mismatch");
static_assert(11 == static_cast<int>(SkBlendMode::kXor), "xfermode_mismatch");
static_assert(16 == static_cast<int>(SkBlendMode::kDarken), "xfermode_mismatch");
static_assert(17 == static_cast<int>(SkBlendMode::kLighten), "xfermode_mismatch");
static_assert(13 == static_cast<int>(SkBlendMode::kModulate), "xfermode_mismatch");
static_assert(14 == static_cast<int>(SkBlendMode::kScreen), "xfermode_mismatch");
static_assert(12 == static_cast<int>(SkBlendMode::kPlus), "xfermode_mismatch");
static_assert(15 == static_cast<int>(SkBlendMode::kOverlay), "xfermode_mismatch");
SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(xfermodeHandle);
SkBlendMode mode = static_cast<SkBlendMode>(xfermodeHandle);
Paint* paint = reinterpret_cast<Paint*>(paintHandle);
paint->setXfermodeMode(mode);
paint->setBlendMode(mode);
}
static jlong setPathEffect(jlong objHandle, jlong effectHandle) {
Paint* obj = reinterpret_cast<Paint*>(objHandle);
SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle);
return reinterpret_cast<jlong>(obj->setPathEffect(effect));
obj->setPathEffect(sk_ref_sp(effect));
return reinterpret_cast<jlong>(obj->getPathEffect());
}
static jlong setMaskFilter(jlong objHandle, jlong maskfilterHandle) {
Paint* obj = reinterpret_cast<Paint*>(objHandle);
SkMaskFilter* maskfilter = reinterpret_cast<SkMaskFilter*>(maskfilterHandle);
return reinterpret_cast<jlong>(obj->setMaskFilter(maskfilter));
obj->setMaskFilter(sk_ref_sp(maskfilter));
return reinterpret_cast<jlong>(obj->getMaskFilter());
}
static jlong setTypeface(jlong objHandle, jlong typefaceHandle) {
@@ -845,8 +850,8 @@ namespace PaintGlue {
static jlong setRasterizer(jlong objHandle, jlong rasterizerHandle) {
Paint* obj = reinterpret_cast<Paint*>(objHandle);
SkAutoTUnref<SkRasterizer> rasterizer(GraphicsJNI::refNativeRasterizer(rasterizerHandle));
return reinterpret_cast<jlong>(obj->setRasterizer(rasterizer));
obj->setRasterizer(GraphicsJNI::refNativeRasterizer(rasterizerHandle));
return reinterpret_cast<jlong>(obj->getRasterizer());
}
static jint getTextAlign(jlong objHandle) {
@@ -940,7 +945,7 @@ namespace PaintGlue {
}
else {
SkScalar sigma = android::uirenderer::Blur::convertRadiusToSigma(radius);
paint->setLooper(SkBlurDrawLooper::Create((SkColor)color, sigma, dx, dy))->unref();
paint->setLooper(SkBlurDrawLooper::Make((SkColor)color, sigma, dx, dy));
}
}

16
core/jni/android/graphics/PathEffect.cpp
View File

@@ -20,7 +20,8 @@ public:
jlong outerHandle, jlong innerHandle) {
SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(outerHandle);
SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(innerHandle);
SkPathEffect* effect = SkComposePathEffect::Create(outer, inner);
SkPathEffect* effect = SkComposePathEffect::Make(sk_ref_sp(outer),
sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(effect);
}
@@ -28,7 +29,8 @@ public:
jlong firstHandle, jlong secondHandle) {
SkPathEffect* first = reinterpret_cast<SkPathEffect*>(firstHandle);
SkPathEffect* second = reinterpret_cast<SkPathEffect*>(secondHandle);
SkPathEffect* effect = SkSumPathEffect::Create(first, second);
SkPathEffect* effect = SkSumPathEffect::Make(sk_ref_sp(first),
sk_ref_sp(second)).release();
return reinterpret_cast<jlong>(effect);
}
@@ -41,7 +43,7 @@ public:
#else
#error Need to convert float array to SkScalar array before calling the following function.
#endif
SkPathEffect* effect = SkDashPathEffect::Create(intervals, count, phase);
SkPathEffect* effect = SkDashPathEffect::Make(intervals, count, phase).release();
return reinterpret_cast<jlong>(effect);
}
@@ -49,19 +51,19 @@ public:
jlong shapeHandle, jfloat advance, jfloat phase, jint style) {
const SkPath* shape = reinterpret_cast<SkPath*>(shapeHandle);
SkASSERT(shape != NULL);
SkPathEffect* effect = SkPath1DPathEffect::Create(*shape, advance, phase,
(SkPath1DPathEffect::Style)style);
SkPathEffect* effect = SkPath1DPathEffect::Make(*shape, advance, phase,
(SkPath1DPathEffect::Style)style).release();
return reinterpret_cast<jlong>(effect);
}
static jlong Corner_constructor(JNIEnv* env, jobject, jfloat radius){
SkPathEffect* effect = SkCornerPathEffect::Create(radius);
SkPathEffect* effect = SkCornerPathEffect::Make(radius).release();
return reinterpret_cast<jlong>(effect);
}
static jlong Discrete_constructor(JNIEnv* env, jobject,
jfloat length, jfloat deviation) {
SkPathEffect* effect = SkDiscretePathEffect::Create(length, deviation);
SkPathEffect* effect = SkDiscretePathEffect::Make(length, deviation).release();
return reinterpret_cast<jlong>(effect);
}

23
core/jni/android/graphics/Picture.cpp
View File

@@ -27,9 +27,9 @@ Picture::Picture(const Picture* src) {
mWidth = src->width();
mHeight = src->height();
if (NULL != src->mPicture.get()) {
mPicture.reset(SkRef(src->mPicture.get()));
mPicture = src->mPicture;
} else if (NULL != src->mRecorder.get()) {
mPicture.reset(src->makePartialCopy());
mPicture = src->makePartialCopy();
}
validate();
} else {
@@ -49,7 +49,7 @@ Canvas* Picture::beginRecording(int width, int height) {
void Picture::endRecording() {
if (NULL != mRecorder.get()) {
mPicture.reset(mRecorder->endRecording());
mPicture = mRecorder->finishRecordingAsPicture();
validate();
mRecorder.reset(NULL);
}
@@ -68,9 +68,9 @@ int Picture::height() const {
Picture* Picture::CreateFromStream(SkStream* stream) {
Picture* newPict = new Picture;
SkPicture* skPicture = SkPicture::CreateFromStream(stream);
sk_sp<SkPicture> skPicture = SkPicture::MakeFromStream(stream);
if (NULL != skPicture) {
newPict->mPicture.reset(skPicture);
newPict->mPicture = skPicture;
const SkIRect cullRect = skPicture->cullRect().roundOut();
newPict->mWidth = cullRect.width();
@@ -82,16 +82,15 @@ Picture* Picture::CreateFromStream(SkStream* stream) {
void Picture::serialize(SkWStream* stream) const {
if (NULL != mRecorder.get()) {
std::unique_ptr<SkPicture> tempPict(this->makePartialCopy());
tempPict->serialize(stream);
this->makePartialCopy()->serialize(stream);
} else if (NULL != mPicture.get()) {
validate();
mPicture->serialize(stream);
} else {
// serialize "empty" picture
SkPictureRecorder recorder;
recorder.beginRecording(0, 0);
std::unique_ptr<SkPicture> empty(recorder.endRecording());
empty->serialize(stream);
recorder.finishRecordingAsPicture()->serialize(stream);
}
}
@@ -102,18 +101,18 @@ void Picture::draw(Canvas* canvas) {
}
validate();
if (NULL != mPicture.get()) {
mPicture.get()->playback(canvas->asSkCanvas());
mPicture->playback(canvas->asSkCanvas());
}
}
SkPicture* Picture::makePartialCopy() const {
sk_sp<SkPicture> Picture::makePartialCopy() const {
SkASSERT(NULL != mRecorder.get());
SkPictureRecorder reRecorder;
SkCanvas* canvas = reRecorder.beginRecording(mWidth, mHeight, NULL, 0);
mRecorder->partialReplay(canvas);
return reRecorder.endRecording();
return reRecorder.finishRecordingAsPicture();
}
void Picture::validate() const {

4
core/jni/android/graphics/Picture.h
View File

@@ -55,12 +55,12 @@ public:
private:
int mWidth;
int mHeight;
SkAutoTUnref<const SkPicture> mPicture;
sk_sp<SkPicture> mPicture;
std::unique_ptr<SkPictureRecorder> mRecorder;
// Make a copy of a picture that is in the midst of being recorded. The
// resulting picture will have balanced saves and restores.
SkPicture* makePartialCopy() const;
sk_sp<SkPicture> makePartialCopy() const;
void validate() const;
};

8
core/jni/android/graphics/Rasterizer.cpp
View File

@@ -34,19 +34,19 @@ public:
virtual ~NativeRasterizer() {}
// Can return NULL, or a ref to the skia rasterizer.
virtual SkRasterizer* refRasterizer() { return NULL; }
virtual sk_sp<SkRasterizer> refRasterizer() { return NULL; }
};
class NativeLayerRasterizer : public NativeRasterizer {
public:
SkLayerRasterizer::Builder fBuilder;
virtual SkRasterizer* refRasterizer() {
return fBuilder.snapshotRasterizer();
virtual sk_sp<SkRasterizer> refRasterizer() {
return fBuilder.snapshot();
}
};
SkRasterizer* GraphicsJNI::refNativeRasterizer(jlong rasterizerHandle) {
sk_sp<SkRasterizer> GraphicsJNI::refNativeRasterizer(jlong rasterizerHandle) {
NativeRasterizer* nr = reinterpret_cast<NativeRasterizer*>(rasterizerHandle);
return nr ? nr->refRasterizer() : NULL;
}

30
core/jni/android/graphics/Shader.cpp
View File

@@ -79,9 +79,9 @@ static jlong Shader_setLocalMatrix(JNIEnv* env, jobject o, jlong shaderHandle, j
if (proxyMatrix == *matrix) {
return reinterpret_cast<jlong>(currentShader.detach());
}
return reinterpret_cast<jlong>(baseShader->newWithLocalMatrix(*matrix));
return reinterpret_cast<jlong>(baseShader->makeWithLocalMatrix(*matrix).release());
}
return reinterpret_cast<jlong>(currentShader->newWithLocalMatrix(*matrix));
return reinterpret_cast<jlong>(currentShader->makeWithLocalMatrix(*matrix).release());
}
///////////////////////////////////////////////////////////////////////////////////////////////
@@ -126,9 +126,9 @@ static jlong LinearGradient_create1(JNIEnv* env, jobject o,
#error Need to convert float array to SkScalar array before calling the following function.
#endif
SkShader* shader = SkGradientShader::CreateLinear(pts,
SkShader* shader = SkGradientShader::MakeLinear(pts,
reinterpret_cast<const SkColor*>(colorValues), pos, count,
static_cast<SkShader::TileMode>(tileMode));
static_cast<SkShader::TileMode>(tileMode)).release();
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
ThrowIAE_IfNull(env, shader);
@@ -147,7 +147,7 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,
colors[0] = color0;
colors[1] = color1;
SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode);
SkShader* s = SkGradientShader::MakeLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode).release();
ThrowIAE_IfNull(env, s);
return reinterpret_cast<jlong>(s);
@@ -170,9 +170,9 @@ static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jf
#error Need to convert float array to SkScalar array before calling the following function.
#endif
SkShader* shader = SkGradientShader::CreateRadial(center, radius,
SkShader* shader = SkGradientShader::MakeRadial(center, radius,
reinterpret_cast<const SkColor*>(colorValues), pos, count,
static_cast<SkShader::TileMode>(tileMode));
static_cast<SkShader::TileMode>(tileMode)).release();
env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues),
JNI_ABORT);
@@ -189,8 +189,8 @@ static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jf
colors[0] = color0;
colors[1] = color1;
SkShader* s = SkGradientShader::CreateRadial(center, radius, colors, NULL, 2,
(SkShader::TileMode)tileMode);
SkShader* s = SkGradientShader::MakeRadial(center, radius, colors, NULL, 2,
(SkShader::TileMode)tileMode).release();
ThrowIAE_IfNull(env, s);
return reinterpret_cast<jlong>(s);
}
@@ -209,8 +209,8 @@ static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y,
#error Need to convert float array to SkScalar array before calling the following function.
#endif
SkShader* shader = SkGradientShader::CreateSweep(x, y,
reinterpret_cast<const SkColor*>(colors), pos, count);
SkShader* shader = SkGradientShader::MakeSweep(x, y,
reinterpret_cast<const SkColor*>(colors), pos, count).release();
env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
JNI_ABORT);
ThrowIAE_IfNull(env, shader);
@@ -222,7 +222,7 @@ static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y,
SkColor colors[2];
colors[0] = color0;
colors[1] = color1;
SkShader* s = SkGradientShader::CreateSweep(x, y, colors, NULL, 2);
SkShader* s = SkGradientShader::MakeSweep(x, y, colors, NULL, 2).release();
ThrowIAE_IfNull(env, s);
return reinterpret_cast<jlong>(s);
}
@@ -234,8 +234,10 @@ static jlong ComposeShader_create(JNIEnv* env, jobject o,
{
SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle);
SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle);
SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(xfermodeHandle);
SkShader* shader = SkShader::CreateComposeShader(shaderA, shaderB, mode);
SkBlendMode mode = static_cast<SkBlendMode>(xfermodeHandle);
SkShader* shader = SkShader::MakeComposeShader(sk_ref_sp(shaderA),
sk_ref_sp(shaderB),
(SkXfermode::Mode)mode).release();
return reinterpret_cast<jlong>(shader);
}

2
core/jni/android/graphics/pdf/PdfDocument.cpp
View File

@@ -81,7 +81,7 @@ public:
assert(mCurrentPage != NULL);
assert(mCurrentPage->mPictureRecorder != NULL);
assert(mCurrentPage->mPicture == NULL);
mCurrentPage->mPicture = mCurrentPage->mPictureRecorder->endRecording();
mCurrentPage->mPicture = mCurrentPage->mPictureRecorder->finishRecordingAsPicture().release();
delete mCurrentPage->mPictureRecorder;
mCurrentPage->mPictureRecorder = NULL;
mCurrentPage = NULL;

2
core/jni/android_graphics_Canvas.cpp
View File

@@ -207,7 +207,7 @@ static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle, jlong devic
}
static void drawColor(JNIEnv* env, jobject, jlong canvasHandle, jint color, jint modeHandle) {
SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(modeHandle);
SkBlendMode mode = static_cast<SkBlendMode>(modeHandle);
get_canvas(canvasHandle)->drawColor(color, mode);
}

22
libs/hwui/BakedOpDispatcher.cpp
View File

@@ -292,7 +292,7 @@ static void renderText(BakedOpRenderer& renderer, const TextOp& op, const BakedO
Rect layerBounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
int alpha = PaintUtils::getAlphaDirect(op.paint) * state.alpha;
SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(op.paint);
SkBlendMode mode = PaintUtils::getBlendModeDirect(op.paint);
TextDrawFunctor functor(&renderer, &state, renderClip,
x, y, pureTranslate, alpha, mode, op.paint);
@@ -528,7 +528,7 @@ void BakedOpDispatcher::onBitmapRectOp(BakedOpRenderer& renderer, const BitmapRe
void BakedOpDispatcher::onColorOp(BakedOpRenderer& renderer, const ColorOp& op, const BakedOpState& state) {
SkPaint paint;
paint.setColor(op.color);
paint.setXfermodeMode(op.mode);
paint.setBlendMode(op.mode);
Glop glop;
GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
@@ -744,7 +744,7 @@ void BakedOpDispatcher::onTextOnPathOp(BakedOpRenderer& renderer, const TextOnPa
Rect layerBounds(FLT_MAX / 2.0f, FLT_MAX / 2.0f, FLT_MIN / 2.0f, FLT_MIN / 2.0f);
int alpha = PaintUtils::getAlphaDirect(op.paint) * state.alpha;
SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(op.paint);
SkBlendMode mode = PaintUtils::getBlendModeDirect(op.paint);
TextDrawFunctor functor(&renderer, &state, renderTargetClip,
0.0f, 0.0f, false, alpha, mode, op.paint);
@@ -776,11 +776,11 @@ void BakedOpDispatcher::onTextureLayerOp(BakedOpRenderer& renderer, const Textur
}
void renderRectForLayer(BakedOpRenderer& renderer, const LayerOp& op, const BakedOpState& state,
int color, SkXfermode::Mode mode, SkColorFilter* colorFilter) {
int color, SkBlendMode mode, SkColorFilter* colorFilter) {
SkPaint paint;
paint.setColor(color);
paint.setXfermodeMode(mode);
paint.setColorFilter(colorFilter);
paint.setBlendMode(mode);
paint.setColorFilter(sk_ref_sp(colorFilter));
RectOp rectOp(op.unmappedBounds, op.localMatrix, op.localClip, &paint);
BakedOpDispatcher::onRectOp(renderer, rectOp, state);
}
@@ -808,11 +808,11 @@ void BakedOpDispatcher::onLayerOp(BakedOpRenderer& renderer, const LayerOp& op,
if (CC_UNLIKELY(Properties::debugLayersUpdates)) {
// render debug layer highlight
renderRectForLayer(renderer, op, state,
0x7f00ff00, SkXfermode::Mode::kSrcOver_Mode, nullptr);
0x7f00ff00, SkBlendMode::kSrcOver, nullptr);
} else if (CC_UNLIKELY(Properties::debugOverdraw)) {
// render transparent to increment overdraw for repaint area
renderRectForLayer(renderer, op, state,
SK_ColorTRANSPARENT, SkXfermode::Mode::kSrcOver_Mode, nullptr);
SK_ColorTRANSPARENT, SkBlendMode::kSrcOver, nullptr);
}
}
}
@@ -829,14 +829,14 @@ void BakedOpDispatcher::onCopyFromLayerOp(BakedOpRenderer& renderer, const CopyF
if (op.paint && op.paint->getAlpha() < 255) {
SkPaint layerPaint;
layerPaint.setAlpha(op.paint->getAlpha());
layerPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
layerPaint.setColorFilter(op.paint->getColorFilter());
layerPaint.setBlendMode(SkBlendMode::kDstIn);
layerPaint.setColorFilter(sk_ref_sp(op.paint->getColorFilter()));
RectOp rectOp(state.computedState.clippedBounds, Matrix4::identity(), nullptr, &layerPaint);
BakedOpDispatcher::onRectOp(renderer, rectOp, state);
}
OffscreenBuffer& layer = **(op.layerHandle);
auto mode = PaintUtils::getXfermodeDirect(op.paint);
auto mode = PaintUtils::getBlendModeDirect(op.paint);
Glop glop;
GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
.setRoundRectClipState(state.roundRectClipState)

2
libs/hwui/DeferredLayerUpdater.cpp
View File

@@ -45,7 +45,7 @@ DeferredLayerUpdater::~DeferredLayerUpdater() {
void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
mAlpha = PaintUtils::getAlphaDirect(paint);
mMode = PaintUtils::getXfermodeDirect(paint);
mMode = PaintUtils::getBlendModeDirect(paint);
SkColorFilter* colorFilter = (paint) ? paint->getColorFilter() : nullptr;
SkRefCnt_SafeAssign(mColorFilter, colorFilter);
}

2
libs/hwui/DeferredLayerUpdater.h
View File

@@ -101,7 +101,7 @@ private:
bool mBlend;
SkColorFilter* mColorFilter;
int mAlpha;
SkXfermode::Mode mMode;
SkBlendMode mMode;
sp<GLConsumer> mSurfaceTexture;
SkMatrix* mTransform;
bool mNeedsGLContextAttach;

4
libs/hwui/FontRenderer.h
View File

@@ -58,7 +58,7 @@ public:
const BakedOpState* bakedState,
const ClipBase* clip,
float x, float y, bool pureTranslate,
int alpha, SkXfermode::Mode mode, const SkPaint* paint)
int alpha, SkBlendMode mode, const SkPaint* paint)
: renderer(renderer)
, bakedState(bakedState)
, clip(clip)
@@ -79,7 +79,7 @@ public:
float y;
bool pureTranslate;
int alpha;
SkXfermode::Mode mode;
SkBlendMode mode;
const SkPaint* paint;
};

6
libs/hwui/FrameBuilder.cpp
View File

@@ -608,7 +608,7 @@ void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
// MergingDrawBatch::canMergeWith()
if (bakedState->computedState.transform.isSimple()
&& bakedState->computedState.transform.positiveScale()
&& PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
&& PaintUtils::getBlendModeDirect(op.paint) == SkBlendMode::kSrcOver
&& op.bitmap->colorType() != kAlpha_8_SkColorType
&& hasMergeableClip(*bakedState)) {
mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
@@ -683,7 +683,7 @@ void FrameBuilder::deferPatchOp(const PatchOp& op) {
if (!bakedState) return; // quick rejected
if (bakedState->computedState.transform.isPureTranslate()
&& PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
&& PaintUtils::getBlendModeDirect(op.paint) == SkBlendMode::kSrcOver
&& hasMergeableClip(*bakedState)) {
mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
@@ -750,7 +750,7 @@ void FrameBuilder::deferTextOp(const TextOp& op) {
batchid_t batchId = textBatchId(*(op.paint));
if (bakedState->computedState.transform.isPureTranslate()
&& PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
&& PaintUtils::getBlendModeDirect(op.paint) == SkBlendMode::kSrcOver
&& hasMergeableClip(*bakedState)) {
mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor());
currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId);

36
libs/hwui/GlopBuilder.cpp
View File

@@ -220,9 +220,9 @@ GlopBuilder& GlopBuilder::setMeshPatchQuads(const Patch& patch) {
////////////////////////////////////////////////////////////////////////////////
void GlopBuilder::setFill(int color, float alphaScale,
SkXfermode::Mode mode, Blend::ModeOrderSwap modeUsage,
SkBlendMode mode, Blend::ModeOrderSwap modeUsage,
const SkShader* shader, const SkColorFilter* colorFilter) {
if (mode != SkXfermode::kClear_Mode) {
if (mode != SkBlendMode::kClear) {
if (!shader) {
FloatColor c;
c.set(color);
@@ -246,8 +246,8 @@ void GlopBuilder::setFill(int color, float alphaScale,
|| mOutGlop->roundRectClipState
|| PaintUtils::isBlendedShader(shader)
|| PaintUtils::isBlendedColorFilter(colorFilter)
|| mode != SkXfermode::kSrcOver_Mode) {
if (CC_LIKELY(mode <= SkXfermode::kScreen_Mode)) {
|| mode != SkBlendMode::kSrcOver) {
if (CC_LIKELY(mode <= SkBlendMode::kScreen)) {
Blend::getFactors(mode, modeUsage,
&mOutGlop->blend.src, &mOutGlop->blend.dst);
} else {
@@ -257,12 +257,12 @@ void GlopBuilder::setFill(int color, float alphaScale,
// If the blend mode cannot be implemented using shaders, fall
// back to the default SrcOver blend mode instead
if (CC_UNLIKELY(mCaches.extensions().hasFramebufferFetch())) {
mDescription.framebufferMode = mode;
mDescription.framebufferMode = (SkXfermode::Mode)mode;
mDescription.swapSrcDst = (modeUsage == Blend::ModeOrderSwap::Swap);
// blending in shader, don't enable
} else {
// unsupported
Blend::getFactors(SkXfermode::kSrcOver_Mode, modeUsage,
Blend::getFactors(SkBlendMode::kSrcOver, modeUsage,
&mOutGlop->blend.src, &mOutGlop->blend.dst);
}
}
@@ -271,11 +271,11 @@ void GlopBuilder::setFill(int color, float alphaScale,
if (colorFilter) {
SkColor color;
SkXfermode::Mode mode;
SkXfermode::Mode xmode;
SkScalar srcColorMatrix[20];
if (colorFilter->asColorMode(&color, &mode)) {
if (colorFilter->asColorMode(&color, &xmode)) {
mOutGlop->fill.filterMode = mDescription.colorOp = ProgramDescription::ColorFilterMode::Blend;
mDescription.colorMode = mode;
mDescription.colorMode = xmode;
mOutGlop->fill.filter.color.set(color);
} else if (colorFilter->asColorMatrix(srcColorMatrix)) {
mOutGlop->fill.filterMode = mDescription.colorOp = ProgramDescription::ColorFilterMode::Matrix;
@@ -321,7 +321,7 @@ GlopBuilder& GlopBuilder::setFillTexturePaint(Texture& texture,
shader = nullptr;
}
setFill(color, alphaScale,
PaintUtils::getXfermode(paint->getXfermode()), Blend::ModeOrderSwap::NoSwap,
paint->getBlendMode(), Blend::ModeOrderSwap::NoSwap,
shader, paint->getColorFilter());
} else {
mOutGlop->fill.color = { alphaScale, alphaScale, alphaScale, alphaScale };
@@ -330,7 +330,7 @@ GlopBuilder& GlopBuilder::setFillTexturePaint(Texture& texture,
|| (mOutGlop->mesh.vertices.attribFlags & VertexAttribFlags::Alpha)
|| texture.blend
|| mOutGlop->roundRectClipState) {
Blend::getFactors(SkXfermode::kSrcOver_Mode, Blend::ModeOrderSwap::NoSwap,
Blend::getFactors(SkBlendMode::kSrcOver, Blend::ModeOrderSwap::NoSwap,
&mOutGlop->blend.src, &mOutGlop->blend.dst);
} else {
mOutGlop->blend = { GL_ZERO, GL_ZERO };
@@ -360,7 +360,7 @@ GlopBuilder& GlopBuilder::setFillPaint(const SkPaint& paint, float alphaScale, b
}
setFill(paint.getColor(), alphaScale,
PaintUtils::getXfermode(paint.getXfermode()), Blend::ModeOrderSwap::NoSwap,
paint.getBlendMode(), Blend::ModeOrderSwap::NoSwap,
paint.getShader(), paint.getColorFilter());
mDescription.useShadowAlphaInterp = shadowInterp;
mDescription.modulate = mOutGlop->fill.color.a < 1.0f;
@@ -376,7 +376,7 @@ GlopBuilder& GlopBuilder::setFillPathTexturePaint(PathTexture& texture,
mOutGlop->fill.texture = { &texture, GL_TEXTURE_2D, GL_INVALID_ENUM, GL_INVALID_ENUM, nullptr };
setFill(paint.getColor(), alphaScale,
PaintUtils::getXfermode(paint.getXfermode()), Blend::ModeOrderSwap::NoSwap,
paint.getBlendMode(), Blend::ModeOrderSwap::NoSwap,
paint.getShader(), paint.getColorFilter());
mDescription.hasAlpha8Texture = true;
@@ -400,7 +400,7 @@ GlopBuilder& GlopBuilder::setFillShadowTexturePaint(ShadowTexture& texture, int
}
setFill(shadowColor, alphaScale,
PaintUtils::getXfermode(paint.getXfermode()), Blend::ModeOrderSwap::NoSwap,
paint.getBlendMode(), Blend::ModeOrderSwap::NoSwap,
paint.getShader(), paint.getColorFilter());
mDescription.hasAlpha8Texture = true;
@@ -413,7 +413,7 @@ GlopBuilder& GlopBuilder::setFillBlack() {
REQUIRE_STAGES(kMeshStage | kRoundRectClipStage);
mOutGlop->fill.texture = { nullptr, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM, nullptr };
setFill(SK_ColorBLACK, 1.0f, SkXfermode::kSrcOver_Mode, Blend::ModeOrderSwap::NoSwap,
setFill(SK_ColorBLACK, 1.0f, SkBlendMode::kSrcOver, Blend::ModeOrderSwap::NoSwap,
nullptr, nullptr);
return *this;
}
@@ -423,13 +423,13 @@ GlopBuilder& GlopBuilder::setFillClear() {
REQUIRE_STAGES(kMeshStage | kRoundRectClipStage);
mOutGlop->fill.texture = { nullptr, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM, nullptr };
setFill(SK_ColorBLACK, 1.0f, SkXfermode::kClear_Mode, Blend::ModeOrderSwap::NoSwap,
setFill(SK_ColorBLACK, 1.0f, SkBlendMode::kClear, Blend::ModeOrderSwap::NoSwap,
nullptr, nullptr);
return *this;
}
GlopBuilder& GlopBuilder::setFillLayer(Texture& texture, const SkColorFilter* colorFilter,
float alpha, SkXfermode::Mode mode, Blend::ModeOrderSwap modeUsage) {
float alpha, SkBlendMode mode, Blend::ModeOrderSwap modeUsage) {
TRIGGER_STAGE(kFillStage);
REQUIRE_STAGES(kMeshStage | kRoundRectClipStage);
@@ -465,7 +465,7 @@ GlopBuilder& GlopBuilder::setFillExternalTexture(Texture& texture, Matrix4& text
GL_TEXTURE_EXTERNAL_OES, GL_LINEAR, GL_CLAMP_TO_EDGE,
&textureTransform };
setFill(SK_ColorWHITE, 1.0f, SkXfermode::kSrc_Mode, Blend::ModeOrderSwap::NoSwap,
setFill(SK_ColorWHITE, 1.0f, SkBlendMode::kSrc, Blend::ModeOrderSwap::NoSwap,
nullptr, nullptr);
mDescription.modulate = mOutGlop->fill.color.a < 1.0f;

4
libs/hwui/GlopBuilder.h
View File

@@ -70,7 +70,7 @@ public:
GlopBuilder& setFillBlack();
GlopBuilder& setFillClear();
GlopBuilder& setFillLayer(Texture& texture, const SkColorFilter* colorFilter,
float alpha, SkXfermode::Mode mode, Blend::ModeOrderSwap modeUsage);
float alpha, SkBlendMode mode, Blend::ModeOrderSwap modeUsage);
GlopBuilder& setFillTextureLayer(Layer& layer, float alpha);
// TODO: Texture should probably know and own its target.
// setFillLayer() forces it to GL_TEXTURE which isn't always correct.
@@ -112,7 +112,7 @@ public:
static void dump(const Glop& glop);
private:
void setFill(int color, float alphaScale,
SkXfermode::Mode mode, Blend::ModeOrderSwap modeUsage,
SkBlendMode mode, Blend::ModeOrderSwap modeUsage,
const SkShader* shader, const SkColorFilter* colorFilter);
enum StageFlags {

8
libs/hwui/Layer.h
View File

@@ -28,7 +28,7 @@
#include <ui/Region.h>
#include <SkPaint.h>
#include <SkXfermode.h>
#include <SkBlendMode.h>
#include "Matrix.h"
#include "Rect.h"
@@ -98,7 +98,7 @@ public:
this->alpha = alpha;
}
inline void setAlpha(int alpha, SkXfermode::Mode mode) {
inline void setAlpha(int alpha, SkBlendMode mode) {
this->alpha = alpha;
this->mode = mode;
}
@@ -107,7 +107,7 @@ public:
return alpha;
}
inline SkXfermode::Mode getMode() const {
inline SkBlendMode getMode() const {
return mode;
}
@@ -208,7 +208,7 @@ private:
/**
* Blending mode of the layer.
*/
SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode;
SkBlendMode mode = SkBlendMode::kSrcOver;
/**
* Optional texture coordinates transform.

2
libs/hwui/LayerBuilder.cpp
View File

@@ -274,7 +274,7 @@ void LayerBuilder::flushLayerClears(LinearAllocator& allocator) {
// One or more unclipped saveLayers have been enqueued, with deferred clears.
// Flush all of these clears with a single draw
SkPaint* paint = allocator.create<SkPaint>();
paint->setXfermodeMode(SkXfermode::kClear_Mode);
paint->setBlendMode(SkBlendMode::kClear);
SimpleRectsOp* op = allocator.create_trivial<SimpleRectsOp>(bounds,
Matrix4::identity(), nullptr, paint,
verts, vertCount);

5
libs/hwui/PathCache.cpp
View File

@@ -17,6 +17,8 @@
#include <SkBitmap.h>
#include <SkCanvas.h>
#include <SkColor.h>
#include <SkColorFilter.h>
#include <SkMaskFilter.h>
#include <SkPaint.h>
#include <SkPath.h>
#include <SkPathEffect.h>
@@ -149,8 +151,7 @@ static void initPaint(SkPaint& paint) {
paint.setColorFilter(nullptr);
paint.setMaskFilter(nullptr);
paint.setShader(nullptr);
SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrc_Mode);
SkSafeUnref(paint.setXfermode(mode));
paint.setBlendMode(SkBlendMode::kSrc);
}
static SkBitmap* drawPath(const SkPath* path, const SkPaint* paint, PathTexture* texture,

9
libs/hwui/RecordedOp.h
View File

@@ -26,7 +26,6 @@
#include "Vector.h"
#include <androidfw/ResourceTypes.h>
#include <SkXfermode.h>
class SkBitmap;
class SkPaint;
@@ -257,12 +256,12 @@ struct CirclePropsOp : RecordedOp {
struct ColorOp : RecordedOp {
// Note: unbounded op that will fillclip, so no bounds/matrix needed
ColorOp(const ClipBase* localClip, int color, SkXfermode::Mode mode)
ColorOp(const ClipBase* localClip, int color, SkBlendMode mode)
: RecordedOp(RecordedOpId::ColorOp, Rect(), Matrix4::identity(), localClip, nullptr)
, color(color)
, mode(mode) {}
const int color;
const SkXfermode::Mode mode;
const SkBlendMode mode;
};
struct FunctorOp : RecordedOp {
@@ -504,7 +503,7 @@ struct LayerOp : RecordedOp {
: SUPER_PAINTLESS(LayerOp)
, layerHandle(layerHandle)
, alpha(paint ? paint->getAlpha() / 255.0f : 1.0f)
, mode(PaintUtils::getXfermodeDirect(paint))
, mode(PaintUtils::getBlendModeDirect(paint))
, colorFilter(paint ? paint->getColorFilter() : nullptr) {}
explicit LayerOp(RenderNode& node)
@@ -518,7 +517,7 @@ struct LayerOp : RecordedOp {
// constructed until after this operation is constructed.
OffscreenBuffer** layerHandle;
const float alpha;
const SkXfermode::Mode mode;
const SkBlendMode mode;
// pointer to object owned by either LayerProperties, or a recorded Paint object in a
// BeginLayerOp. Lives longer than LayerOp in either case, so no skia ref counting is used.

2
libs/hwui/RecordingCanvas.cpp
View File

@@ -247,7 +247,7 @@ bool RecordingCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) {
// ----------------------------------------------------------------------------
// android/graphics/Canvas draw operations
// ----------------------------------------------------------------------------
void RecordingCanvas::drawColor(int color, SkXfermode::Mode mode) {
void RecordingCanvas::drawColor(int color, SkBlendMode mode) {
addOp(alloc().create_trivial<ColorOp>(
getRecordedClip(),
color,

2
libs/hwui/RecordingCanvas.h
View File

@@ -144,7 +144,7 @@ public:
// ----------------------------------------------------------------------------
// android/graphics/Canvas draw operations
// ----------------------------------------------------------------------------
virtual void drawColor(int color, SkXfermode::Mode mode) override;
virtual void drawColor(int color, SkBlendMode mode) override;
virtual void drawPaint(const SkPaint& paint) override;
// Geometry

2
libs/hwui/RenderProperties.cpp
View File

@@ -52,7 +52,7 @@ bool LayerProperties::setColorFilter(SkColorFilter* filter) {
bool LayerProperties::setFromPaint(const SkPaint* paint) {
bool changed = false;
changed |= setAlpha(static_cast<uint8_t>(PaintUtils::getAlphaDirect(paint)));
changed |= setXferMode(PaintUtils::getXfermodeDirect(paint));
changed |= setXferMode(PaintUtils::getBlendModeDirect(paint));
changed |= setColorFilter(paint ? paint->getColorFilter() : nullptr);
return changed;
}

8
libs/hwui/RenderProperties.h
View File

@@ -24,10 +24,10 @@
#include "utils/MathUtils.h"
#include "utils/PaintUtils.h"
#include <SkBlendMode.h>
#include <SkCamera.h>
#include <SkMatrix.h>
#include <SkRegion.h>
#include <SkXfermode.h>
#include <algorithm>
#include <stddef.h>
@@ -93,11 +93,11 @@ public:
return mAlpha;
}
bool setXferMode(SkXfermode::Mode mode) {
bool setXferMode(SkBlendMode mode) {
return RP_SET(mMode, mode);
}
SkXfermode::Mode xferMode() const {
SkBlendMode xferMode() const {
return mMode;
}
@@ -133,7 +133,7 @@ private:
// Whether or not that Layer's content is opaque, doesn't include alpha
bool mOpaque;
uint8_t mAlpha;
SkXfermode::Mode mMode;
SkBlendMode mMode;
SkColorFilter* mColorFilter = nullptr;
};

2
libs/hwui/SkiaCanvas.cpp
View File

@@ -386,7 +386,7 @@ void SkiaCanvas::setDrawFilter(SkDrawFilter* drawFilter) {
// Canvas draw operations
// ----------------------------------------------------------------------------
void SkiaCanvas::drawColor(int color, SkXfermode::Mode mode) {
void SkiaCanvas::drawColor(int color, SkBlendMode mode) {
mCanvas->drawColor(color, mode);
}

2
libs/hwui/SkiaCanvas.h
View File

@@ -100,7 +100,7 @@ public:
virtual SkDrawFilter* getDrawFilter() override;
virtual void setDrawFilter(SkDrawFilter* drawFilter) override;
virtual void drawColor(int color, SkXfermode::Mode mode) override;
virtual void drawColor(int color, SkBlendMode mode) override;
virtual void drawPaint(const SkPaint& paint) override;
virtual void drawPoint(float x, float y, const SkPaint& paint) override;

12
libs/hwui/VectorDrawable.cpp
View File

@@ -201,10 +201,7 @@ void FullPath::drawPath(SkCanvas* outCanvas, SkPath& renderPath, float strokeSca
SkPaint paint;
if (properties.getFillGradient() != nullptr) {
paint.setColor(applyAlpha(SK_ColorBLACK, properties.getFillAlpha()));
SkShader* newShader = properties.getFillGradient()->newWithLocalMatrix(matrix);
// newWithLocalMatrix(...) creates a new SkShader and returns a bare pointer. We need to
// remove the extra ref so that the ref count is correctly managed.
paint.setShader(newShader)->unref();
paint.setShader(properties.getFillGradient()->makeWithLocalMatrix(matrix));
needsFill = true;
} else if (properties.getFillColor() != SK_ColorTRANSPARENT) {
paint.setColor(applyAlpha(properties.getFillColor(), properties.getFillAlpha()));
@@ -223,10 +220,7 @@ void FullPath::drawPath(SkCanvas* outCanvas, SkPath& renderPath, float strokeSca
bool needsStroke = false;
if (properties.getStrokeGradient() != nullptr) {
paint.setColor(applyAlpha(SK_ColorBLACK, properties.getStrokeAlpha()));
SkShader* newShader = properties.getStrokeGradient()->newWithLocalMatrix(matrix);
// newWithLocalMatrix(...) creates a new SkShader and returns a bare pointer. We need to
// remove the extra ref so that the ref count is correctly managed.
paint.setShader(newShader)->unref();
paint.setShader(properties.getStrokeGradient()->makeWithLocalMatrix(matrix));
needsStroke = true;
} else if (properties.getStrokeColor() != SK_ColorTRANSPARENT) {
paint.setColor(applyAlpha(properties.getStrokeColor(), properties.getStrokeAlpha()));
@@ -534,7 +528,7 @@ SkPaint* Tree::updatePaint(SkPaint* outPaint, TreeProperties* prop) {
if (prop->getRootAlpha() == 1.0f && prop->getColorFilter() == nullptr) {
return nullptr;
} else {
outPaint->setColorFilter(prop->getColorFilter());
outPaint->setColorFilter(sk_ref_sp(prop->getColorFilter()));
outPaint->setFilterQuality(kLow_SkFilterQuality);
outPaint->setAlpha(prop->getRootAlpha() * 255);
return outPaint;

2
libs/hwui/hwui/Canvas.h
View File

@@ -174,7 +174,7 @@ public:
// ----------------------------------------------------------------------------
// Canvas draw operations
// ----------------------------------------------------------------------------
virtual void drawColor(int color, SkXfermode::Mode mode) = 0;
virtual void drawColor(int color, SkBlendMode mode) = 0;
virtual void drawPaint(const SkPaint& paint) = 0;
// Geometry

109
libs/hwui/renderstate/Blend.cpp
View File

@@ -25,70 +25,70 @@ namespace uirenderer {
* Structure mapping Skia xfermodes to OpenGL blending factors.
*/
struct Blender {
SkXfermode::Mode mode;
SkBlendMode mode;
GLenum src;
GLenum dst;
};
// assumptions made by lookup tables in either this file or ProgramCache
static_assert(0 == SkXfermode::kClear_Mode, "SkXfermode enums have changed");
static_assert(1 == SkXfermode::kSrc_Mode, "SkXfermode enums have changed");
static_assert(2 == SkXfermode::kDst_Mode, "SkXfermode enums have changed");
static_assert(3 == SkXfermode::kSrcOver_Mode, "SkXfermode enums have changed");
static_assert(4 == SkXfermode::kDstOver_Mode, "SkXfermode enums have changed");
static_assert(5 == SkXfermode::kSrcIn_Mode, "SkXfermode enums have changed");
static_assert(6 == SkXfermode::kDstIn_Mode, "SkXfermode enums have changed");
static_assert(7 == SkXfermode::kSrcOut_Mode, "SkXfermode enums have changed");
static_assert(8 == SkXfermode::kDstOut_Mode, "SkXfermode enums have changed");
static_assert(9 == SkXfermode::kSrcATop_Mode, "SkXfermode enums have changed");
static_assert(10 == SkXfermode::kDstATop_Mode, "SkXfermode enums have changed");
static_assert(11 == SkXfermode::kXor_Mode, "SkXfermode enums have changed");
static_assert(12 == SkXfermode::kPlus_Mode, "SkXfermode enums have changed");
static_assert(13 == SkXfermode::kModulate_Mode, "SkXfermode enums have changed");
static_assert(14 == SkXfermode::kScreen_Mode, "SkXfermode enums have changed");
static_assert(15 == SkXfermode::kOverlay_Mode, "SkXfermode enums have changed");
static_assert(16 == SkXfermode::kDarken_Mode, "SkXfermode enums have changed");
static_assert(17 == SkXfermode::kLighten_Mode, "SkXfermode enums have changed");
static_assert(0 == static_cast<int>(SkBlendMode::kClear), "SkBlendMode enums have changed");
static_assert(1 == static_cast<int>(SkBlendMode::kSrc), "SkBlendMode enums have changed");
static_assert(2 == static_cast<int>(SkBlendMode::kDst), "SkBlendMode enums have changed");
static_assert(3 == static_cast<int>(SkBlendMode::kSrcOver), "SkBlendMode enums have changed");
static_assert(4 == static_cast<int>(SkBlendMode::kDstOver), "SkBlendMode enums have changed");
static_assert(5 == static_cast<int>(SkBlendMode::kSrcIn), "SkBlendMode enums have changed");
static_assert(6 == static_cast<int>(SkBlendMode::kDstIn), "SkBlendMode enums have changed");
static_assert(7 == static_cast<int>(SkBlendMode::kSrcOut), "SkBlendMode enums have changed");
static_assert(8 == static_cast<int>(SkBlendMode::kDstOut), "SkBlendMode enums have changed");
static_assert(9 == static_cast<int>(SkBlendMode::kSrcATop), "SkBlendMode enums have changed");
static_assert(10 == static_cast<int>(SkBlendMode::kDstATop), "SkBlendMode enums have changed");
static_assert(11 == static_cast<int>(SkBlendMode::kXor), "SkBlendMode enums have changed");
static_assert(12 == static_cast<int>(SkBlendMode::kPlus), "SkBlendMode enums have changed");
static_assert(13 == static_cast<int>(SkBlendMode::kModulate), "SkBlendMode enums have changed");
static_assert(14 == static_cast<int>(SkBlendMode::kScreen), "SkBlendMode enums have changed");
static_assert(15 == static_cast<int>(SkBlendMode::kOverlay), "SkBlendMode enums have changed");
static_assert(16 == static_cast<int>(SkBlendMode::kDarken), "SkBlendMode enums have changed");
static_assert(17 == static_cast<int>(SkBlendMode::kLighten), "SkBlendMode enums have changed");
// In this array, the index of each Blender equals the value of the first
// entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode]
// entry. For instance, gBlends[1] == gBlends[SkBlendMode::kSrc]
const Blender kBlends[] = {
{ SkXfermode::kClear_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kSrc_Mode, GL_ONE, GL_ZERO },
{ SkXfermode::kDst_Mode, GL_ZERO, GL_ONE },
{ SkXfermode::kSrcOver_Mode, GL_ONE, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kDstOver_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE },
{ SkXfermode::kSrcIn_Mode, GL_DST_ALPHA, GL_ZERO },
{ SkXfermode::kDstIn_Mode, GL_ZERO, GL_SRC_ALPHA },
{ SkXfermode::kSrcOut_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkXfermode::kDstOut_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kSrcATop_Mode, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kDstATop_Mode, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
{ SkXfermode::kXor_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kPlus_Mode, GL_ONE, GL_ONE },
{ SkXfermode::kModulate_Mode, GL_ZERO, GL_SRC_COLOR },
{ SkXfermode::kScreen_Mode, GL_ONE, GL_ONE_MINUS_SRC_COLOR }
{ SkBlendMode::kClear, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kSrc, GL_ONE, GL_ZERO },
{ SkBlendMode::kDst, GL_ZERO, GL_ONE },
{ SkBlendMode::kSrcOver, GL_ONE, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kDstOver, GL_ONE_MINUS_DST_ALPHA, GL_ONE },
{ SkBlendMode::kSrcIn, GL_DST_ALPHA, GL_ZERO },
{ SkBlendMode::kDstIn, GL_ZERO, GL_SRC_ALPHA },
{ SkBlendMode::kSrcOut, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkBlendMode::kDstOut, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kSrcATop, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kDstATop, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
{ SkBlendMode::kXor, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kPlus, GL_ONE, GL_ONE },
{ SkBlendMode::kModulate, GL_ZERO, GL_SRC_COLOR },
{ SkBlendMode::kScreen, GL_ONE, GL_ONE_MINUS_SRC_COLOR }
};
// This array contains the swapped version of each SkXfermode. For instance
// This array contains the swapped version of each SkBlendMode. For instance
// this array's SrcOver blending mode is actually DstOver. You can refer to
// createLayer() for more information on the purpose of this array.
const Blender kBlendsSwap[] = {
{ SkXfermode::kClear_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkXfermode::kSrc_Mode, GL_ZERO, GL_ONE },
{ SkXfermode::kDst_Mode, GL_ONE, GL_ZERO },
{ SkXfermode::kSrcOver_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE },
{ SkXfermode::kDstOver_Mode, GL_ONE, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kSrcIn_Mode, GL_ZERO, GL_SRC_ALPHA },
{ SkXfermode::kDstIn_Mode, GL_DST_ALPHA, GL_ZERO },
{ SkXfermode::kSrcOut_Mode, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kDstOut_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkXfermode::kSrcATop_Mode, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
{ SkXfermode::kDstATop_Mode, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kXor_Mode, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkXfermode::kPlus_Mode, GL_ONE, GL_ONE },
{ SkXfermode::kModulate_Mode, GL_DST_COLOR, GL_ZERO },
{ SkXfermode::kScreen_Mode, GL_ONE_MINUS_DST_COLOR, GL_ONE }
{ SkBlendMode::kClear, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkBlendMode::kSrc, GL_ZERO, GL_ONE },
{ SkBlendMode::kDst, GL_ONE, GL_ZERO },
{ SkBlendMode::kSrcOver, GL_ONE_MINUS_DST_ALPHA, GL_ONE },
{ SkBlendMode::kDstOver, GL_ONE, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kSrcIn, GL_ZERO, GL_SRC_ALPHA },
{ SkBlendMode::kDstIn, GL_DST_ALPHA, GL_ZERO },
{ SkBlendMode::kSrcOut, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kDstOut, GL_ONE_MINUS_DST_ALPHA, GL_ZERO },
{ SkBlendMode::kSrcATop, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA },
{ SkBlendMode::kDstATop, GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kXor, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA },
{ SkBlendMode::kPlus, GL_ONE, GL_ONE },
{ SkBlendMode::kModulate, GL_DST_COLOR, GL_ZERO },
{ SkBlendMode::kScreen, GL_ONE_MINUS_DST_COLOR, GL_ONE }
};
Blend::Blend()
@@ -111,9 +111,10 @@ void Blend::syncEnabled() {
}
}
void Blend::getFactors(SkXfermode::Mode mode, ModeOrderSwap modeUsage, GLenum* outSrc, GLenum* outDst) {
*outSrc = (modeUsage == ModeOrderSwap::Swap) ? kBlendsSwap[mode].src : kBlends[mode].src;
*outDst = (modeUsage == ModeOrderSwap::Swap) ? kBlendsSwap[mode].dst : kBlends[mode].dst;
void Blend::getFactors(SkBlendMode mode, ModeOrderSwap modeUsage, GLenum* outSrc, GLenum* outDst) {
int index = static_cast<int>(mode);
*outSrc = (modeUsage == ModeOrderSwap::Swap) ? kBlendsSwap[index].src : kBlends[index].src;
*outDst = (modeUsage == ModeOrderSwap::Swap) ? kBlendsSwap[index].dst : kBlends[index].dst;
}
void Blend::setFactors(GLenum srcMode, GLenum dstMode) {

4
libs/hwui/renderstate/Blend.h
View File

@@ -20,7 +20,7 @@
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <SkXfermode.h>
#include <SkBlendMode.h>
#include <memory>
namespace android {
@@ -36,7 +36,7 @@ public:
};
void syncEnabled();
static void getFactors(SkXfermode::Mode mode, ModeOrderSwap modeUsage,
static void getFactors(SkBlendMode mode, ModeOrderSwap modeUsage,
GLenum* outSrc, GLenum* outDst);
void setFactors(GLenum src, GLenum dst);

2
libs/hwui/tests/common/TestListViewSceneBase.cpp
View File

@@ -47,7 +47,7 @@ void TestListViewSceneBase::createContent(int width, int height, Canvas& canvas)
}
});
canvas.drawColor(Color::Grey_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Grey_500, SkBlendMode::kSrcOver);
canvas.drawRenderNode(mListView.get());
}

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

@@ -29,7 +29,7 @@ class ClippingAnimation : public TestScene {
public:
sp<RenderNode> card;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
card = TestUtils::createNode(0, 0, 200, 400,
[](RenderProperties& props, Canvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
@@ -39,7 +39,7 @@ public:
canvas.rotate(45);
canvas.translate(-100, -100);
canvas.clipRect(0, 0, 200, 200, SkRegion::kIntersect_Op);
canvas.drawColor(Color::Blue_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Blue_500, SkBlendMode::kSrcOver);
}
canvas.restore();
@@ -48,7 +48,7 @@ public:
SkPath clipCircle;
clipCircle.addCircle(100, 300, 100);
canvas.clipPath(&clipCircle, SkRegion::kIntersect_Op);
canvas.drawColor(Color::Red_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
}
canvas.restore();

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

@@ -37,7 +37,7 @@ public:
container = TestUtils::createNode(0, 0, width, height, nullptr);
doFrame(0); // update container
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
canvas.drawRenderNode(container.get());
}

4
libs/hwui/tests/common/scenes/HwLayerAnimation.cpp
View File

@@ -32,9 +32,9 @@ public:
card = TestUtils::createNode(0, 0, 200, 200,
[](RenderProperties& props, Canvas& canvas) {
props.mutateLayerProperties().setType(LayerType::RenderLayer);
canvas.drawColor(0xFF0000FF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFF0000FF, SkBlendMode::kSrcOver);
});
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode); // background
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver); // background
canvas.drawRenderNode(card.get());
}
void doFrame(int frameNr) override {

9
libs/hwui/tests/common/scenes/ListOfFadedTextAnimation.cpp
View File

@@ -31,7 +31,7 @@ static TestScene::Registrar _ListOfFadedTextAnimation(TestScene::Info{
class ListOfFadedTextAnimation : public TestListViewSceneBase {
void createListItem(RenderProperties& props, Canvas& canvas, int id,
int itemWidth, int itemHeight) override {
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
int length = dp(100);
canvas.saveLayer(0, 0, length, itemHeight, nullptr, SaveFlags::HasAlphaLayer);
SkPaint textPaint;
@@ -44,16 +44,15 @@ class ListOfFadedTextAnimation : public TestListViewSceneBase {
pts[1].set(0, 1);
SkColor colors[2] = {Color::Black, Color::Transparent};
SkAutoTUnref<SkShader> s(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
sk_sp<SkShader> s(SkGradientShader::MakeLinear(pts, colors, NULL, 2,
SkShader::kClamp_TileMode));
SkMatrix matrix;
matrix.setScale(1, length);
matrix.postRotate(-90);
SkPaint fadingPaint;
fadingPaint.setShader(s->newWithLocalMatrix(matrix))->unref();
SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstOut_Mode);
fadingPaint.setXfermode(mode);
fadingPaint.setShader(s->makeWithLocalMatrix(matrix));
fadingPaint.setBlendMode(SkBlendMode::kDstOut);
canvas.drawRect(0, 0, length, itemHeight, fadingPaint);
canvas.restore();
}

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

@@ -53,7 +53,7 @@ public:
mCircleX->value = width * 0.75;
mCircleY->value = height * 0.75;
canvas.drawColor(Color::White, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
canvas.drawRoundRect(mRoundRectLeft.get(), mRoundRectTop.get(),
mRoundRectRight.get(), mRoundRectBottom.get(),
mRoundRectRx.get(), mRoundRectRy.get(), mPaint.get());

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

@@ -29,7 +29,7 @@ class OvalAnimation : public TestScene {
public:
sp<RenderNode> card;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
card = TestUtils::createNode(0, 0, 200, 200,
[](RenderProperties& props, Canvas& canvas) {
SkPaint paint;

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

@@ -37,7 +37,7 @@ public:
0xFF4CAF50,
};
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
for (int x = dp(16); x < (width - dp(116)); x += dp(116)) {
for (int y = dp(16); y < (height - dp(116)); y += dp(116)) {
@@ -45,7 +45,7 @@ public:
sp<RenderNode> card = TestUtils::createNode(x, y,
x + dp(100), y + dp(100),
[color](RenderProperties& props, Canvas& canvas) {
canvas.drawColor(color, SkXfermode::kSrcOver_Mode);
canvas.drawColor(color, SkBlendMode::kSrcOver);
});
canvas.drawRenderNode(card.get());
cards.push_back(card);
@@ -61,7 +61,7 @@ public:
TestUtils::recordNode(*cards[0], [curFrame](Canvas& canvas) {
SkColor color = TestUtils::interpolateColor(
curFrame / 150.0f, 0xFFF44336, 0xFFF8BBD0);
canvas.drawColor(color, SkXfermode::kSrcOver_Mode);
canvas.drawColor(color, SkBlendMode::kSrcOver);
});
}
};

4
libs/hwui/tests/common/scenes/RecentsAnimation.cpp
View File

@@ -39,7 +39,7 @@ public:
thumbnailSize = std::min(std::min(width, height) / 2, 720);
int cardsize = std::min(width, height) - dp(64);
renderer.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
renderer.drawColor(Color::White, SkBlendMode::kSrcOver);
renderer.insertReorderBarrier(true);
int x = dp(32);
@@ -76,7 +76,7 @@ private:
props.mutableOutline().setRoundRect(0, 0, width, height, dp(10), 1);
props.mutableOutline().setShouldClip(true);
canvas.drawColor(Color::Grey_200, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Grey_200, SkBlendMode::kSrcOver);
canvas.drawBitmap(thumb, 0, 0, thumb.width(), thumb.height(),
0, 0, width, height, nullptr);
});

4
libs/hwui/tests/common/scenes/RectGridAnimation.cpp
View File

@@ -30,12 +30,12 @@ class RectGridAnimation : public TestScene {
public:
sp<RenderNode> card;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
canvas.insertReorderBarrier(true);
card = TestUtils::createNode(50, 50, 250, 250,
[](RenderProperties& props, Canvas& canvas) {
canvas.drawColor(0xFFFF00FF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFF00FF, SkBlendMode::kSrcOver);
SkRegion region;
for (int xOffset = 0; xOffset < 200; xOffset+=2) {

4
libs/hwui/tests/common/scenes/RoundRectClippingAnimation.cpp
View File

@@ -28,7 +28,7 @@ public:
std::vector< sp<RenderNode> > cards;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
canvas.insertReorderBarrier(true);
int ci = 0;
@@ -37,7 +37,7 @@ public:
auto color = BrightColors[ci++ % BrightColorsCount];
auto card = TestUtils::createNode(x, y, x + mSize, y + mSize,
[&](RenderProperties& props, Canvas& canvas) {
canvas.drawColor(color, SkXfermode::kSrcOver_Mode);
canvas.drawColor(color, SkBlendMode::kSrcOver);
props.mutableOutline().setRoundRect(0, 0,
props.getWidth(), props.getHeight(), mSize * .25, 1);
props.mutableOutline().setShouldClip(true);

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

@@ -29,16 +29,16 @@ class SaveLayerAnimation : public TestScene {
public:
sp<RenderNode> card;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode); // background
canvas.drawColor(Color::White, SkBlendMode::kSrcOver); // background
card = TestUtils::createNode(0, 0, 400, 800,
[](RenderProperties& props, Canvas& canvas) {
// nested clipped saveLayers
canvas.saveLayerAlpha(0, 0, 400, 400, 200, SaveFlags::ClipToLayer);
canvas.drawColor(Color::Green_700, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Green_700, SkBlendMode::kSrcOver);
canvas.clipRect(50, 50, 350, 350, SkRegion::kIntersect_Op);
canvas.saveLayerAlpha(100, 100, 300, 300, 128, SaveFlags::ClipToLayer);
canvas.drawColor(Color::Blue_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Blue_500, SkBlendMode::kSrcOver);
canvas.restore();
canvas.restore();

4
libs/hwui/tests/common/scenes/ShadowGrid2Animation.cpp
View File

@@ -29,7 +29,7 @@ class ShadowGrid2Animation : public TestScene {
public:
std::vector< sp<RenderNode> > cards;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
canvas.insertReorderBarrier(true);
for (int x = dp(8); x < (width - dp(58)); x += dp(58)) {
@@ -57,7 +57,7 @@ private:
props.setElevation(dp(16));
props.mutableOutline().setRoundRect(0, 0, width, height, dp(6), 1);
props.mutableOutline().setShouldClip(true);
canvas.drawColor(0xFFEEEEEE, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFEEEEEE, SkBlendMode::kSrcOver);
});
}
};

4
libs/hwui/tests/common/scenes/ShadowGridAnimation.cpp
View File

@@ -29,7 +29,7 @@ class ShadowGridAnimation : public TestScene {
public:
std::vector< sp<RenderNode> > cards;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
canvas.insertReorderBarrier(true);
for (int x = dp(16); x < (width - dp(116)); x += dp(116)) {
@@ -57,7 +57,7 @@ private:
props.setElevation(dp(16));
props.mutableOutline().setRoundRect(0, 0, width, height, dp(6), 1);
props.mutableOutline().setShouldClip(true);
canvas.drawColor(0xFFEEEEEE, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFEEEEEE, SkBlendMode::kSrcOver);
});
}
};

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

@@ -83,7 +83,7 @@ public:
for (auto op : ops) {
int innerCount = canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(0, 0, cellSize, cellSize, SkRegion::kIntersect_Op);
canvas.drawColor(Color::White, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
op(canvas, cellSize, paint);
canvas.restoreToCount(innerCount);
canvas.translate(cellSize + cellSpace, 0);
@@ -94,7 +94,7 @@ public:
}
canvas.restoreToCount(outerCount);
});
canvas.drawColor(Color::Grey_500, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(Color::Grey_500, SkBlendMode::kSrcOver);
canvas.drawRenderNode(card.get());
}

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

@@ -29,7 +29,7 @@ class TextAnimation : public TestScene {
public:
sp<RenderNode> card;
void createContent(int width, int height, Canvas& canvas) override {
canvas.drawColor(Color::White, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::White, SkBlendMode::kSrcOver);
card = TestUtils::createNode(0, 0, width, height,
[](RenderProperties& props, Canvas& canvas) {
SkPaint paint;

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

@@ -163,7 +163,7 @@ BENCHMARK(BM_CanvasState_translate);
void BM_DisplayListCanvas_basicViewGroupDraw(benchmark::State& benchState) {
sp<RenderNode> child = TestUtils::createNode(50, 50, 100, 100,
[](auto& props, auto& canvas) {
canvas.drawColor(0xFFFFFFFF, SkXfermode::kSrcOver_Mode);
canvas.drawColor(0xFFFFFFFF, SkBlendMode::kSrcOver);
});
std::unique_ptr<Canvas> canvas(Canvas::create_recording_canvas(100, 100));

12
libs/hwui/tests/unit/BakedOpDispatcherTests.cpp
View File

@@ -86,9 +86,7 @@ RENDERTHREAD_TEST(BakedOpDispatcher, pathTexture_positionOvalArc) {
strokePaint.setStrokeWidth(4);
float intervals[] = {1.0f, 1.0f};
auto dashEffect = SkDashPathEffect::Create(intervals, 2, 0);
strokePaint.setPathEffect(dashEffect);
dashEffect->unref();
strokePaint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
auto textureGlopVerifier = [] (const Glop& glop) {
// validate glop produced by renderPathTexture (so texture, unit quad)
@@ -167,7 +165,7 @@ RENDERTHREAD_TEST(BakedOpDispatcher, renderTextWithShadow) {
shadowPaint.setColor(SK_ColorRED);
SkScalar sigma = Blur::convertRadiusToSigma(5);
shadowPaint.setLooper(SkBlurDrawLooper::Create(SK_ColorWHITE, sigma, 3, 3))->unref();
shadowPaint.setLooper(SkBlurDrawLooper::Make(SK_ColorWHITE, sigma, 3, 3));
TestUtils::drawUtf8ToCanvas(&canvas, "A", shadowPaint, 25, 25);
TestUtils::drawUtf8ToCanvas(&canvas, "B", shadowPaint, 50, 50);
@@ -202,8 +200,8 @@ static void validateLayerDraw(renderthread::RenderThread& renderThread,
props.mutateLayerProperties().setType(LayerType::RenderLayer);
// provide different blend mode, so decoration draws contrast
props.mutateLayerProperties().setXferMode(SkXfermode::Mode::kSrc_Mode);
canvas.drawColor(Color::Black, SkXfermode::Mode::kSrcOver_Mode);
props.mutateLayerProperties().setXferMode(SkBlendMode::kSrc);
canvas.drawColor(Color::Black, SkBlendMode::kSrcOver);
});
OffscreenBuffer** layerHandle = node->getLayerHandle();
@@ -287,4 +285,4 @@ RENDERTHREAD_TEST(BakedOpDispatcher, pathTextureSnapping) {
EXPECT_EQ(1, reinterpret_cast<PathTexture*>(texture)->left);
EXPECT_EQ(3, reinterpret_cast<PathTexture*>(texture)->top);
});
}
}

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

@@ -721,7 +721,7 @@ RENDERTHREAD_TEST(FrameBuilder, deferColorOp_unbounded) {
auto unclippedColorView = TestUtils::createNode<RecordingCanvas>(0, 0, 10, 10,
[](RenderProperties& props, RecordingCanvas& canvas) {
props.setClipToBounds(false);
canvas.drawColor(SK_ColorWHITE, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
});
FrameBuilder frameBuilder(SkRect::MakeWH(200, 200), 200, 200,
@@ -974,7 +974,7 @@ RENDERTHREAD_TEST(FrameBuilder, saveLayerUnclipped_simple) {
void onSimpleRectsOp(const SimpleRectsOp& op, const BakedOpState& state) override {
EXPECT_EQ(1, mIndex++);
ASSERT_NE(nullptr, op.paint);
ASSERT_EQ(SkXfermode::kClear_Mode, PaintUtils::getXfermodeDirect(op.paint));
ASSERT_EQ(SkBlendMode::kClear, PaintUtils::getBlendModeDirect(op.paint));
}
void onRectOp(const RectOp& op, const BakedOpState& state) override {
EXPECT_EQ(2, mIndex++);
@@ -1108,7 +1108,7 @@ RENDERTHREAD_TEST(FrameBuilder, saveLayerUnclipped_clearClip) {
void onSimpleRectsOp(const SimpleRectsOp& op, const BakedOpState& state) override {
EXPECT_EQ(1, mIndex++);
ASSERT_NE(nullptr, op.paint);
EXPECT_EQ(SkXfermode::kClear_Mode, PaintUtils::getXfermodeDirect(op.paint));
EXPECT_EQ(SkBlendMode::kClear, PaintUtils::getBlendModeDirect(op.paint));
EXPECT_EQ(Rect(50, 50, 150, 150), state.computedState.clippedBounds)
<< "Expect dirty rect as clip";
ASSERT_NE(nullptr, state.computedState.clipState);
@@ -1433,7 +1433,7 @@ RENDERTHREAD_TEST(FrameBuilder, buildLayer) {
auto node = TestUtils::createNode<RecordingCanvas>(10, 10, 110, 110,
[](RenderProperties& props, RecordingCanvas& canvas) {
props.mutateLayerProperties().setType(LayerType::RenderLayer);
canvas.drawColor(SK_ColorWHITE, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
});
OffscreenBuffer** layerHandle = node->getLayerHandle();
@@ -2196,7 +2196,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, SkRegion::kReplace_Op);
canvas.drawColor(SK_ColorWHITE, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
});
FrameBuilder frameBuilder(SkRect::MakeLTRB(10, 10, 40, 40), 50, 50,

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

@@ -249,7 +249,7 @@ TEST(RecordingCanvas, drawGlyphs_forceAlignLeft) {
TEST(RecordingCanvas, drawColor) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) {
canvas.drawColor(Color::Black, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Black, SkBlendMode::kSrcOver);
});
ASSERT_EQ(1u, dl->getOps().size()) << "Must be exactly one op";
@@ -639,7 +639,7 @@ TEST(RecordingCanvas, replaceClipIntersectWithRoot) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(100, 100, [](RecordingCanvas& canvas) {
canvas.save(SaveFlags::MatrixClip);
canvas.clipRect(-10, -10, 110, 110, SkRegion::kReplace_Op);
canvas.drawColor(SK_ColorWHITE, SkXfermode::Mode::kSrcOver_Mode);
canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrcOver);
canvas.restore();
});
ASSERT_EQ(1u, dl->getOps().size()) << "Must have one op";
@@ -773,7 +773,7 @@ TEST(RecordingCanvas, refBitmapInShader_composeShader) {
SkShader::TileMode::kRepeat_TileMode);
sk_sp<SkShader> composeShader = SkShader::MakeComposeShader(std::move(shader1), std::move(shader2),
SkXfermode::Mode::kMultiply_Mode);
SkXfermode::kMultiply_Mode);
paint.setShader(std::move(composeShader));
canvas.drawRoundRect(0, 0, 100, 100, 20.0f, 20.0f, paint);
});

6
libs/hwui/tests/unit/RenderNodeTests.cpp
View File

@@ -41,7 +41,7 @@ public:
TEST(RenderNode, hasParents) {
auto child = TestUtils::createNode(0, 0, 200, 400,
[](RenderProperties& props, Canvas& canvas) {
canvas.drawColor(Color::Red_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
});
auto parent = TestUtils::createNode(0, 0, 200, 400,
[&child](RenderProperties& props, Canvas& canvas) {
@@ -54,7 +54,7 @@ TEST(RenderNode, hasParents) {
EXPECT_FALSE(parent->hasParents()) << "Root node shouldn't have any parents";
TestUtils::recordNode(*parent, [](Canvas& canvas) {
canvas.drawColor(Color::Amber_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Amber_500, SkBlendMode::kSrcOver);
});
EXPECT_TRUE(child->hasParents()) << "Child should still have a parent";
@@ -117,7 +117,7 @@ RENDERTHREAD_TEST(RenderNode, prepareTree_nullableDisplayList) {
{
auto nonNullDLNode = TestUtils::createNode(0, 0, 200, 400,
[](RenderProperties& props, Canvas& canvas) {
canvas.drawColor(Color::Red_500, SkXfermode::kSrcOver_Mode);
canvas.drawColor(Color::Red_500, SkBlendMode::kSrcOver);
});
TestUtils::syncHierarchyPropertiesAndDisplayList(nonNullDLNode);
EXPECT_TRUE(nonNullDLNode->getDisplayList());

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

@@ -57,8 +57,8 @@ TEST(SkiaBehavior, genIds) {
TEST(SkiaBehavior, lightingColorFilter_simplify) {
{
SkAutoTUnref<SkColorFilter> filter(
SkColorMatrixFilter::CreateLightingFilter(0x11223344, 0));
sk_sp<SkColorFilter> filter(
SkColorMatrixFilter::MakeLightingFilter(0x11223344, 0));
SkColor observedColor;
SkXfermode::Mode observedMode;
@@ -68,20 +68,20 @@ TEST(SkiaBehavior, lightingColorFilter_simplify) {
}
{
SkAutoTUnref<SkColorFilter> failFilter(
SkColorMatrixFilter::CreateLightingFilter(0x11223344, 0x1));
sk_sp<SkColorFilter> failFilter(
SkColorMatrixFilter::MakeLightingFilter(0x11223344, 0x1));
EXPECT_FALSE(failFilter->asColorMode(nullptr, nullptr));
}
}
TEST(SkiaBehavior, porterDuffCreateIsCached) {
SkPaint paint;
paint.setXfermodeMode(SkXfermode::kOverlay_Mode);
auto expected = paint.getXfermode();
paint.setXfermodeMode(SkXfermode::kClear_Mode);
ASSERT_NE(expected, paint.getXfermode());
paint.setXfermodeMode(SkXfermode::kOverlay_Mode);
ASSERT_EQ(expected, paint.getXfermode());
paint.setBlendMode(SkBlendMode::kOverlay);
auto expected = paint.getBlendMode();
paint.setBlendMode(SkBlendMode::kClear);
ASSERT_NE(expected, paint.getBlendMode());
paint.setBlendMode(SkBlendMode::kOverlay);
ASSERT_EQ(expected, paint.getBlendMode());
}
TEST(SkiaBehavior, srgbColorSpaceIsSingleton) {

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

@@ -45,7 +45,7 @@ TEST(SkiaCanvasProxy, drawGlyphsViaPicture) {
SkCanvas* skCanvas = recorder.beginRecording(200, 200, NULL, 0);
std::unique_ptr<Canvas> pictCanvas(Canvas::create_canvas(skCanvas));
TestUtils::drawUtf8ToCanvas(pictCanvas.get(), text, paint, 25, 25);
SkAutoTUnref<const SkPicture> picture(recorder.endRecording());
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
canvas.asSkCanvas()->drawPicture(picture);
});

4
libs/hwui/utils/NinePatchImpl.cpp
View File

@@ -134,7 +134,7 @@ void NinePatch::Draw(SkCanvas* canvas, const SkRect& bounds,
if (bounds.isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
(paint && paint->getXfermode() == NULL && paint->getAlpha() == 0))
(paint && paint->isSrcOver() && paint->getAlpha() == 0))
{
if (kUseTrace) {
ALOGV("======== abort ninepatch draw\n");
@@ -149,7 +149,7 @@ void NinePatch::Draw(SkCanvas* canvas, const SkRect& bounds,
if (bitmap.getPixels() == NULL)
return;
const bool hasXfer = paint->getXfermode() != NULL;
const bool hasXfer = !paint->isSrcOver();
SkRect dst;
SkIRect src;

26
libs/hwui/utils/PaintUtils.h
View File

@@ -33,18 +33,6 @@ namespace uirenderer {
class PaintUtils {
public:
/**
* Safely retrieves the mode from the specified xfermode. If the specified
* xfermode is null, the mode is assumed to be SkXfermode::kSrcOver_Mode.
*/
static inline SkXfermode::Mode getXfermode(SkXfermode* mode) {
SkXfermode::Mode resultMode;
if (!SkXfermode::AsMode(mode, &resultMode)) {
resultMode = SkXfermode::kSrcOver_Mode;
}
return resultMode;
}
static inline GLenum getFilter(const SkPaint* paint) {
if (!paint || paint->getFilterQuality() != kNone_SkFilterQuality) {
return GL_LINEAR;
@@ -56,7 +44,7 @@ public:
static inline bool paintWillNotDraw(const SkPaint& paint) {
return paint.getAlpha() == 0
&& !paint.getColorFilter()
&& getXfermode(paint.getXfermode()) == SkXfermode::kSrcOver_Mode;
&& paint.getBlendMode() == SkBlendMode::kSrcOver;
}
// TODO: move to a method on android:Paint? replace with SkPaint::nothingToDraw()?
@@ -64,7 +52,7 @@ public:
return paint.getAlpha() == 0
&& paint.getLooper() == nullptr
&& !paint.getColorFilter()
&& getXfermode(paint.getXfermode()) == SkXfermode::kSrcOver_Mode;
&& paint.getBlendMode() == SkBlendMode::kSrcOver;
}
static bool isOpaquePaint(const SkPaint* paint) {
@@ -77,9 +65,9 @@ public:
}
// Only let simple srcOver / src blending modes declare opaque, since behavior is clear.
SkXfermode::Mode mode = getXfermode(paint->getXfermode());
return mode == SkXfermode::Mode::kSrcOver_Mode
|| mode == SkXfermode::Mode::kSrc_Mode;
SkBlendMode mode = paint->getBlendMode();
return mode == SkBlendMode::kSrcOver
|| mode == SkBlendMode::kSrc;
}
static bool isBlendedShader(const SkShader* shader) {
@@ -121,8 +109,8 @@ public:
return getTextShadow(paint, nullptr);
}
static inline SkXfermode::Mode getXfermodeDirect(const SkPaint* paint) {
return paint ? getXfermode(paint->getXfermode()) : SkXfermode::kSrcOver_Mode;
static inline SkBlendMode getBlendModeDirect(const SkPaint* paint) {
return paint ? paint->getBlendMode() : SkBlendMode::kSrcOver;
}
static inline int getAlphaDirect(const SkPaint* paint) {

2
libs/input/SpriteController.cpp
View File

@@ -216,7 +216,7 @@ void SpriteController::doUpdateSprites() {
SkCanvas surfaceCanvas(surfaceBitmap);
SkPaint paint;
paint.setXfermodeMode(SkXfermode::kSrc_Mode);
paint.setBlendMode(SkBlendMode::kSrc);
surfaceCanvas.drawBitmap(update.state.icon.bitmap, 0, 0, &paint);
if (outBuffer.width > update.state.icon.bitmap.width()) {