drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pass Bitmap instead of SkBitmap in canvas.drawBitmap(Bitmap, float,float,Paint)

Browse Source 
Test: refactoring cl.
bug:32216791

Change-Id: If9f9fbc19e683b14cce6c3c268258bd832d495d2
This commit is contained in:
sergeyv
2016-10-14 16:30:21 -07:00
parent c1c54062f8
commit aed7f58fb0
21 changed files with 112 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
core/jni/android/graphics/Bitmap.cpp
View File

@ -55,7 +55,10 @@ public:
return !!mBitmap;
}
Bitmap* bitmap() { return mBitmap.get(); }
Bitmap& bitmap() {
assertValid();
return *mBitmap;
}
void assertValid() {
LOG_ALWAYS_FATAL_IF(!valid(), "Error, cannot access an invalid/free'd bitmap here!");
@ -134,7 +137,7 @@ public:
}
void* pixels() {
return mBitmapWrapper->bitmap()->pixels();
return mBitmapWrapper->bitmap().pixels();
}
bool valid() {
@ -200,13 +203,12 @@ void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap) {
bitmap->getSkBitmap(outBitmap);
}
Bitmap* toBitmap(JNIEnv* env, jobject bitmap) {
Bitmap& toBitmap(JNIEnv* env, jobject bitmap) {
SkASSERT(env);
SkASSERT(bitmap);
SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);
LocalScopedBitmap localBitmap(bitmapHandle);
localBitmap->assertValid();
return localBitmap->bitmap();
}
@ -646,7 +648,7 @@ static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,
// Otherwise respect the premultiplied request.
alphaType = requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
}
bitmap->bitmap()->reconfigure(SkImageInfo::Make(width, height, colorType, alphaType,
bitmap->bitmap().reconfigure(SkImageInfo::Make(width, height, colorType, alphaType,
sk_sp<SkColorSpace>(bitmap->info().colorSpace())));
}
@ -941,7 +943,7 @@ static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
// Transfer the underlying ashmem region if we have one and it's immutable.
android::status_t status;
int fd = bitmapWrapper->bitmap()->getAshmemFd();
int fd = bitmapWrapper->bitmap().getAshmemFd();
if (fd >= 0 && !isMutable && p->allowFds()) {
#if DEBUG_PARCEL
ALOGD("Bitmap.writeToParcel: transferring immutable bitmap's ashmem fd as "
@ -1189,9 +1191,9 @@ static jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle,
static jlong Bitmap_refPixelRef(JNIEnv* env, jobject, jlong bitmapHandle) {
LocalScopedBitmap bitmap(bitmapHandle);
SkPixelRef* pixelRef = bitmap->bitmap();
SkSafeRef(pixelRef);
return reinterpret_cast<jlong>(pixelRef);
SkPixelRef& pixelRef = bitmap->bitmap();
pixelRef.ref();
return reinterpret_cast<jlong>(&pixelRef);
}
static void Bitmap_prepareToDraw(JNIEnv* env, jobject, jlong bitmapPtr) {

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

@ -41,7 +41,7 @@ jobject createBitmap(JNIEnv* env, Bitmap* bitmap,
void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap);
Bitmap* toBitmap(JNIEnv* env, jobject bitmap);
Bitmap& toBitmap(JNIEnv* env, jobject bitmap);
/** Reinitialize a bitmap. bitmap must already have its SkAlphaType set in
sync with isPremultiplied

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

@ -330,7 +330,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding
android::Bitmap* reuseBitmap = nullptr;
unsigned int existingBufferSize = 0;
if (javaBitmap != NULL) {
reuseBitmap = bitmap::toBitmap(env, javaBitmap);
reuseBitmap = &bitmap::toBitmap(env, javaBitmap);
if (reuseBitmap->isImmutable()) {
ALOGW("Unable to reuse an immutable bitmap as an image decoder target.");
javaBitmap = NULL;

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

@ -151,7 +151,7 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint in
android::Bitmap* recycledBitmap = nullptr;
size_t recycledBytes = 0;
if (javaBitmap) {
recycledBitmap = bitmap::toBitmap(env, javaBitmap);
recycledBitmap = &bitmap::toBitmap(env, javaBitmap);
if (recycledBitmap->isImmutable()) {
ALOGW("Warning: Reusing an immutable bitmap as an image decoder target.");
}

10
core/jni/android/graphics/Graphics.cpp
View File

@ -337,13 +337,13 @@ SkColorType GraphicsJNI::legacyBitmapConfigToColorType(jint legacyConfig) {
}
void GraphicsJNI::getSkBitmap(JNIEnv* env, jobject bitmap, SkBitmap* outBitmap) {
android::bitmap::toBitmap(env, bitmap)->getSkBitmap(outBitmap);
android::bitmap::toBitmap(env, bitmap).getSkBitmap(outBitmap);
}
SkPixelRef* GraphicsJNI::refSkPixelRef(JNIEnv* env, jobject bitmap) {
SkPixelRef* pixelRef = android::bitmap::toBitmap(env, bitmap);
pixelRef->ref();
return pixelRef;
SkPixelRef* GraphicsJNI::refSkPixelRef(JNIEnv* env, jobject jbitmap) {
android::Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
bitmap.ref();
return &bitmap;
}
SkColorType GraphicsJNI::getNativeBitmapColorType(JNIEnv* env, jobject jconfig) {
SkASSERT(env);

4
core/jni/android/graphics/Movie.cpp
View File

@ -76,8 +76,8 @@ static void movie_draw(JNIEnv* env, jobject movie, jlong canvasHandle,
SkMovie* m = J2Movie(env, movie);
const SkBitmap& b = m->bitmap();
c->drawBitmap(b, fx, fy, p);
sk_sp<android::Bitmap> wrapper = android::Bitmap::createFrom(b.info(), *b.pixelRef());
c->drawBitmap(*wrapper, fx, fy, p);
}
static jobject movie_decodeAsset(JNIEnv* env, jobject clazz, jlong native_asset) {

5
core/jni/android_graphics_Canvas.cpp
View File

@ -372,8 +372,7 @@ static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap
jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
jint screenDensity, jint bitmapDensity) {
Canvas* canvas = get_canvas(canvasHandle);
SkBitmap bitmap;
GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
@ -456,7 +455,7 @@ static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle,
}
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
get_canvas(canvasHandle)->drawBitmap(bitmap, x, y, paint);
get_canvas(canvasHandle)->drawBitmap(*androidBitmap, x, y, paint);
}
static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,

7
libs/hwui/RecordingCanvas.cpp
View File

@ -21,6 +21,7 @@
#include "RenderNode.h"
#include "VectorDrawable.h"
#include "hwui/MinikinUtils.h"
#include "hwui/Bitmap.h"
namespace android {
namespace uirenderer {
@ -468,10 +469,12 @@ void RecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) {
}
// Bitmap-based
void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) {
void RecordingCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) {
SkBitmap skBitmap;
bitmap.getSkBitmap(&skBitmap);
save(SaveFlags::Matrix);
translate(left, top);
drawBitmap(&bitmap, paint);
drawBitmap(&skBitmap, paint);
restore();
}

2
libs/hwui/RecordingCanvas.h
View File

@ -176,7 +176,7 @@ public:
virtual void drawVectorDrawable(VectorDrawableRoot* tree) override;
// Bitmap-based
virtual void drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) override;
virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) override;
virtual void drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
const SkPaint* paint) override;
virtual void drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,

7
libs/hwui/SkiaCanvas.cpp
View File

@ -18,6 +18,7 @@
#include "CanvasProperty.h"
#include "VectorDrawable.h"
#include "hwui/Bitmap.h"
#include "hwui/MinikinUtils.h"
#include <SkDrawable.h>
@ -490,8 +491,10 @@ void SkiaCanvas::drawVertices(SkCanvas::VertexMode vertexMode, int vertexCount,
// Canvas draw operations: Bitmaps
// ----------------------------------------------------------------------------
void SkiaCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) {
mCanvas->drawBitmap(bitmap, left, top, paint);
void SkiaCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) {
SkBitmap skBitmap;
bitmap.getSkBitmap(&skBitmap);
mCanvas->drawBitmap(skBitmap, left, top, paint);
}
void SkiaCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) {

3
libs/hwui/SkiaCanvas.h
View File

@ -124,8 +124,7 @@ public:
const float* verts, const float* tex, const int* colors,
const uint16_t* indices, int indexCount, const SkPaint& paint) override;
virtual void drawBitmap(const SkBitmap& bitmap, float left, float top,
const SkPaint* paint) override;
virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) override;
virtual void drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
const SkPaint* paint) override;
virtual void drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,

5
libs/hwui/SkiaCanvasProxy.cpp
View File

@ -16,6 +16,8 @@
#include "SkiaCanvasProxy.h"
#include "hwui/Bitmap.h"
#include <cutils/log.h>
#include <SkPatchUtils.h>
#include <SkPaint.h>
@ -122,7 +124,8 @@ void SkiaCanvasProxy::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScal
top + bitmap.dimensions().height(),
paint);
} else {
mCanvas->drawBitmap(bitmap, left, top, paint);
auto hwuiBitmap= Bitmap::createFrom(bitmap.info(), *pxRef);
mCanvas->drawBitmap(*hwuiBitmap, left, top, paint);
}
}

13
libs/hwui/hwui/Bitmap.cpp
View File

@ -101,6 +101,19 @@ sk_sp<Bitmap> Bitmap::allocateAshmemBitmap(size_t size, const SkImageInfo& info,
return sk_sp<Bitmap>(new Bitmap(addr, fd, size, info, rowBytes, ctable));
}
void FreePixelRef(void* addr, void* context) {
auto pixelRef = (SkPixelRef*) context;
pixelRef->unlockPixels();
pixelRef->unref();
}
sk_sp<Bitmap> Bitmap::createFrom(const SkImageInfo& info, SkPixelRef& pixelRef) {
pixelRef.ref();
pixelRef.lockPixels();
return sk_sp<Bitmap>(new Bitmap((void*) pixelRef.pixels(), (void*) &pixelRef, FreePixelRef,
info, pixelRef.rowBytes(), pixelRef.colorTable()));
}
void Bitmap::reconfigure(const SkImageInfo& newInfo, size_t rowBytes, SkColorTable* ctable) {
if (kIndex_8_SkColorType != newInfo.colorType()) {
ctable = nullptr;

1
libs/hwui/hwui/Bitmap.h
View File

@ -41,6 +41,7 @@ public:
static sk_sp<Bitmap> allocateAshmemBitmap(size_t allocSize, const SkImageInfo& info,
size_t rowBytes, SkColorTable* ctable);
static sk_sp<Bitmap> createFrom(const SkImageInfo&, SkPixelRef&);
Bitmap(void* address, size_t allocSize, const SkImageInfo& info, size_t rowBytes,
SkColorTable* ctable);
Bitmap(void* address, void* context, FreeFunc freeFunc,

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

@ -65,6 +65,7 @@ class Tree;
};
typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;
class Bitmap;
class Paint;
struct Typeface;
@ -217,7 +218,7 @@ public:
const uint16_t* indices, int indexCount, const SkPaint& paint) = 0;
// Bitmap-based
virtual void drawBitmap(const SkBitmap& bitmap, float left, float top,
virtual void drawBitmap(Bitmap& bitmap, float left, float top,
const SkPaint* paint) = 0;
virtual void drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
const SkPaint* paint) = 0;

13
libs/hwui/tests/common/TestUtils.h
View File

@ -122,6 +122,19 @@ public:
return snapshot;
}
static sk_sp<Bitmap> createBitmap(int width, int height,
SkColorType colorType = kN32_SkColorType) {
SkImageInfo info = SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType);
size_t size = height * info.minRowBytes();
return Bitmap::allocateHeapBitmap(size, info, info.minRowBytes(), nullptr);
}
static sk_sp<Bitmap> createBitmap(int width, int height, SkBitmap* outBitmap) {
SkImageInfo info = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
outBitmap->setInfo(info);
return Bitmap::allocateHeapBitmap(outBitmap, nullptr);
}
static SkBitmap createSkBitmap(int width, int height,
SkColorType colorType = kN32_SkColorType) {
SkBitmap bitmap;

25
libs/hwui/tests/common/scenes/ListViewAnimation.cpp
View File

@ -29,10 +29,11 @@ static TestScene::Registrar _ListView(TestScene::Info{
});
class ListViewAnimation : public TestListViewSceneBase {
SkBitmap createRandomCharIcon(int cardHeight) {
sk_sp<Bitmap> createRandomCharIcon(int cardHeight) {
SkBitmap skBitmap;
int size = cardHeight - (dp(10) * 2);
SkBitmap bitmap = TestUtils::createSkBitmap(size, size);
SkCanvas canvas(bitmap);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(size, size, &skBitmap));
SkCanvas canvas(skBitmap);
canvas.clear(0);
SkPaint paint;
@ -54,11 +55,12 @@ class ListViewAnimation : public TestListViewSceneBase {
return bitmap;
}
static SkBitmap createBoxBitmap(bool filled) {
static sk_sp<Bitmap> createBoxBitmap(bool filled) {
int size = dp(20);
int stroke = dp(2);
SkBitmap bitmap = TestUtils::createSkBitmap(size, size);
SkCanvas canvas(bitmap);
SkBitmap skBitmap;
auto bitmap = TestUtils::createBitmap(size, size, &skBitmap);
SkCanvas canvas(skBitmap);
canvas.clear(Color::Transparent);
SkPaint paint;
@ -72,8 +74,8 @@ class ListViewAnimation : public TestListViewSceneBase {
void createListItem(RenderProperties& props, Canvas& canvas, int cardId,
int itemWidth, int itemHeight) override {
static SkBitmap filledBox = createBoxBitmap(true);
static SkBitmap strokedBox = createBoxBitmap(false);
static sk_sp<Bitmap> filledBox(createBoxBitmap(true));
static sk_sp<Bitmap> strokedBox(createBoxBitmap(false));
// TODO: switch to using round rect clipping, once merging correctly handles that
SkPaint roundRectPaint;
roundRectPaint.setAntiAlias(true);
@ -92,9 +94,10 @@ class ListViewAnimation : public TestListViewSceneBase {
TestUtils::drawUtf8ToCanvas(&canvas, "This is some more text on the card", textPaint,
itemHeight, dp(45));
canvas.drawBitmap(createRandomCharIcon(itemHeight), dp(10), dp(10), nullptr);
auto randomIcon = createRandomCharIcon(itemHeight);
canvas.drawBitmap(*randomIcon, dp(10), dp(10), nullptr);
const SkBitmap& boxBitmap = rand() % 2 ? filledBox : strokedBox;
canvas.drawBitmap(boxBitmap, itemWidth - dp(10) - boxBitmap.width(), dp(10), nullptr);
auto box = rand() % 2 ? filledBox : strokedBox;
canvas.drawBitmap(*box, itemWidth - dp(10) - box->width(), dp(10), nullptr);
}
};

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

@ -93,7 +93,7 @@ void BM_DisplayListCanvas_record_simpleBitmapView(benchmark::State& benchState)
delete canvas->finishRecording();
SkPaint rectPaint;
SkBitmap iconBitmap = TestUtils::createSkBitmap(80, 80);
sk_sp<Bitmap> iconBitmap(TestUtils::createBitmap(80, 80));
while (benchState.KeepRunning()) {
canvas->resetRecording(100, 100);
@ -105,7 +105,7 @@ void BM_DisplayListCanvas_record_simpleBitmapView(benchmark::State& benchState)
{
canvas->save(SaveFlags::MatrixClip);
canvas->translate(10, 10);
canvas->drawBitmap(iconBitmap, 0, 0, nullptr);
canvas->drawBitmap(*iconBitmap, 0, 0, nullptr);
canvas->restore();
}
benchmark::DoNotOptimize(canvas.get());

4
libs/hwui/tests/microbench/FrameBuilderBench.cpp
View File

@ -41,7 +41,7 @@ const BakedOpRenderer::LightInfo sLightInfo = { 128, 128 };
static sp<RenderNode> createTestNode() {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
SkBitmap bitmap = TestUtils::createSkBitmap(10, 10);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(10, 10));
SkPaint paint;
// Alternate between drawing rects and bitmaps, with bitmaps overlapping rects.
@ -50,7 +50,7 @@ static sp<RenderNode> createTestNode() {
for (int i = 0; i < 30; i++) {
canvas.translate(0, 10);
canvas.drawRect(0, 0, 10, 10, paint);
canvas.drawBitmap(bitmap, 5, 0, nullptr);
canvas.drawBitmap(*bitmap, 5, 0, nullptr);
}
canvas.restore();
});

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

@ -129,9 +129,9 @@ RENDERTHREAD_TEST(FrameBuilder, simple) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 100, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
SkBitmap bitmap = TestUtils::createSkBitmap(25, 25);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(25, 25));
canvas.drawRect(0, 0, 100, 200, SkPaint());
canvas.drawBitmap(bitmap, 10, 10, nullptr);
canvas.drawBitmap(*bitmap, 10, 10, nullptr);
});
FrameBuilder frameBuilder(SkRect::MakeWH(100, 200), 100, 200,
sLightGeometry, Caches::getInstance());
@ -200,8 +200,9 @@ RENDERTHREAD_TEST(FrameBuilder, simpleBatching) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
SkBitmap bitmap = TestUtils::createSkBitmap(10, 10,
kAlpha_8_SkColorType); // Disable merging by using alpha 8 bitmap
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(10, 10,
kAlpha_8_SkColorType)); // Disable merging by using alpha 8 bitmap
// Alternate between drawing rects and bitmaps, with bitmaps overlapping rects.
// Rects don't overlap bitmaps, so bitmaps should be brought to front as a group.
@ -209,7 +210,7 @@ RENDERTHREAD_TEST(FrameBuilder, simpleBatching) {
for (int i = 0; i < LOOPS; i++) {
canvas.translate(0, 10);
canvas.drawRect(0, 0, 10, 10, SkPaint());
canvas.drawBitmap(bitmap, 5, 0, nullptr);
canvas.drawBitmap(*bitmap, 5, 0, nullptr);
}
canvas.restore();
});
@ -393,19 +394,19 @@ RENDERTHREAD_TEST(FrameBuilder, avoidOverdraw_rects) {
}
RENDERTHREAD_TEST(FrameBuilder, avoidOverdraw_bitmaps) {
static SkBitmap opaqueBitmap = TestUtils::createSkBitmap(50, 50,
SkColorType::kRGB_565_SkColorType);
static SkBitmap transpBitmap = TestUtils::createSkBitmap(50, 50,
SkColorType::kAlpha_8_SkColorType);
static sk_sp<Bitmap> opaqueBitmap(TestUtils::createBitmap(50, 50,
SkColorType::kRGB_565_SkColorType));
static sk_sp<Bitmap> transpBitmap(TestUtils::createBitmap(50, 50,
SkColorType::kAlpha_8_SkColorType));
class AvoidOverdrawBitmapsTestRenderer : public TestRendererBase {
public:
void onBitmapOp(const BitmapOp& op, const BakedOpState& state) override {
switch(mIndex++) {
case 0:
EXPECT_EQ(opaqueBitmap.pixelRef(), op.bitmap->pixelRef());
EXPECT_EQ(opaqueBitmap.get(), op.bitmap->pixelRef());
break;
case 1:
EXPECT_EQ(transpBitmap.pixelRef(), op.bitmap->pixelRef());
EXPECT_EQ(transpBitmap.get(), op.bitmap->pixelRef());
break;
default:
ADD_FAILURE() << "Only two ops expected.";
@ -417,11 +418,11 @@ RENDERTHREAD_TEST(FrameBuilder, avoidOverdraw_bitmaps) {
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.drawRect(0, 0, 50, 50, SkPaint());
canvas.drawRect(0, 0, 50, 50, SkPaint());
canvas.drawBitmap(transpBitmap, 0, 0, nullptr);
canvas.drawBitmap(*transpBitmap, 0, 0, nullptr);
// only the below draws should remain, since they're
canvas.drawBitmap(opaqueBitmap, 0, 0, nullptr);
canvas.drawBitmap(transpBitmap, 0, 0, nullptr);
canvas.drawBitmap(*opaqueBitmap, 0, 0, nullptr);
canvas.drawBitmap(*transpBitmap, 0, 0, nullptr);
});
FrameBuilder frameBuilder(SkRect::MakeWH(50, 50), 50, 50,
sLightGeometry, Caches::getInstance());
@ -449,23 +450,23 @@ RENDERTHREAD_TEST(FrameBuilder, clippedMerging) {
};
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 100, 100,
[](RenderProperties& props, RecordingCanvas& canvas) {
SkBitmap bitmap = TestUtils::createSkBitmap(20, 20);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(20, 20));
// left side clipped (to inset left half)
canvas.clipRect(10, 0, 50, 100, SkRegion::kReplace_Op);
canvas.drawBitmap(bitmap, 0, 40, nullptr);
canvas.drawBitmap(*bitmap, 0, 40, nullptr);
// top side clipped (to inset top half)
canvas.clipRect(0, 10, 100, 50, SkRegion::kReplace_Op);
canvas.drawBitmap(bitmap, 40, 0, nullptr);
canvas.drawBitmap(*bitmap, 40, 0, nullptr);
// right side clipped (to inset right half)
canvas.clipRect(50, 0, 90, 100, SkRegion::kReplace_Op);
canvas.drawBitmap(bitmap, 80, 40, nullptr);
canvas.drawBitmap(*bitmap, 80, 40, nullptr);
// bottom not clipped, just abutting (inset bottom half)
canvas.clipRect(0, 50, 100, 90, SkRegion::kReplace_Op);
canvas.drawBitmap(bitmap, 40, 70, nullptr);
canvas.drawBitmap(*bitmap, 40, 70, nullptr);
});
FrameBuilder frameBuilder(SkRect::MakeWH(100, 100), 100, 100,
@ -822,8 +823,8 @@ RENDERTHREAD_TEST(FrameBuilder, clipped) {
auto node = TestUtils::createNode<RecordingCanvas>(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
SkBitmap bitmap = TestUtils::createSkBitmap(200, 200);
canvas.drawBitmap(bitmap, 0, 0, nullptr);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(200, 200));
canvas.drawBitmap(*bitmap, 0, 0, nullptr);
});
// clip to small area, should see in receiver

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

@ -261,8 +261,7 @@ TEST(RecordingCanvas, drawColor) {
TEST(RecordingCanvas, backgroundAndImage) {
auto dl = TestUtils::createDisplayList<RecordingCanvas>(100, 200, [](RecordingCanvas& canvas) {
SkBitmap bitmap;
bitmap.setInfo(SkImageInfo::MakeUnknown(25, 25));
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(25, 25));
SkPaint paint;
paint.setColor(SK_ColorBLUE);
@ -278,7 +277,7 @@ TEST(RecordingCanvas, backgroundAndImage) {
canvas.save(SaveFlags::MatrixClip);
canvas.translate(25, 25);
canvas.scale(2, 2);
canvas.drawBitmap(bitmap, 0, 0, nullptr);
canvas.drawBitmap(*bitmap, 0, 0, nullptr);
canvas.restore();
}
canvas.restore();
@ -728,9 +727,9 @@ TEST(RecordingCanvas, refPaint) {
}
TEST(RecordingCanvas, refBitmap) {
SkBitmap bitmap = TestUtils::createSkBitmap(100, 100);
sk_sp<Bitmap> bitmap(TestUtils::createBitmap(100, 100));
auto dl = TestUtils::createDisplayList<RecordingCanvas>(100, 100, [&bitmap](RecordingCanvas& canvas) {
canvas.drawBitmap(bitmap, 0, 0, nullptr);
canvas.drawBitmap(*bitmap, 0, 0, nullptr);
});
auto& bitmaps = dl->getBitmapResources();
EXPECT_EQ(1u, bitmaps.size());