AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert of remove (dumb) canvas::NewRaster, and rename surface::NewRasterPMColor to N32Premul (patchset #3 id:40001 of https://codereview.chromium.org/790733003/)

Browse Source 
Reason for revert:
need to update chrome first

Original issue's description:
> remove (dumb) canvas::NewRaster, and rename surface::NewRasterPMColor to N32Premul
>
> patch from issue 781403002 at patchset 20001 (http://crrev.com/781403002#ps20001)
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/2c1605a1fbaa2e35a27399a34254fb1200ec2ae6

TBR=fmalita@google.com,fmalita@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/791763002
This commit is contained in:
reed 2014-12-09 13:55:20 -08:00 committed by Commit bot
parent 2e3b3e369d
commit a8918a0650
15 changed files with 103 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gm/fatpathfill.cpp
View File

@ -16,7 +16,7 @@
#define REPEAT_LOOP 5
static SkSurface* new_surface(int width, int height) {
return SkSurface::NewRasterN32Premul(width, height);
return SkSurface::NewRasterPMColor(width, height);
}
static void draw_pixel_centers(SkCanvas* canvas) {

1
gyp/skia_for_chromium_defines.gypi
View File

@ -15,7 +15,6 @@
'skia_for_chromium_defines': [
'SK_SUPPORT_LEGACY_TEXTRENDERMODE',
'SK_IGNORE_GPU_LAYER_HOISTING',
'SK_SUPPORT_LEGACY_NewRasterPMColor',
],
},
}

29
include/core/SkCanvas.h
View File

@ -61,6 +61,35 @@ class SK_API SkCanvas : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(SkCanvas)
/**
* Attempt to allocate an offscreen raster canvas, matching the ImageInfo.
* On success, return a new canvas that will draw into that offscreen.
*
* The caller can access the pixels after drawing into this canvas by
* calling readPixels() or peekPixels().
*
* If the requested ImageInfo is opaque (either the colortype is
* intrinsically opaque like RGB_565, or the info's alphatype is kOpaque)
* then the pixel memory may be uninitialized. Otherwise, the pixel memory
* will be initialized to 0, which is interpreted as transparent.
*
* On failure, return NULL. This can fail for several reasons:
* 1. the memory allocation failed (e.g. request is too large)
* 2. invalid ImageInfo (e.g. negative dimensions)
* 3. unsupported ImageInfo for a canvas
* - kUnknown_SkColorType, kIndex_8_SkColorType
* - kIgnore_SkAlphaType
* - this list is not complete, so others may also be unsupported
*
* Note: it is valid to request a supported ImageInfo, but with zero
* dimensions.
*/
static SkCanvas* NewRaster(const SkImageInfo&);
static SkCanvas* NewRasterN32(int width, int height) {
return NewRaster(SkImageInfo::MakeN32Premul(width, height));
}
/**
* Attempt to allocate raster canvas, matching the ImageInfo, that will draw directly into the
* specified pixels. To access the pixels after drawing to them, the caller should call

5
include/core/SkSurface.h
View File

@ -61,14 +61,9 @@ public:
* specified width and height, and populates the rest of info to match
* pixels in SkPMColor format.
*/
#ifdef SK_SUPPORT_LEGACY_NewRasterPMColor
static SkSurface* NewRasterPMColor(int width, int height, const SkSurfaceProps* props = NULL) {
return NewRaster(SkImageInfo::MakeN32Premul(width, height), props);
}
#endif
static SkSurface* NewRasterN32Premul(int width, int height, const SkSurfaceProps* props = NULL) {
return NewRaster(SkImageInfo::MakeN32Premul(width, height), props);
}
/**
* Return a new surface using the specified render target.

6
samplecode/SamplePictFile.cpp
View File

@ -136,6 +136,12 @@ private:
SkDebugf("coun't load picture at \"path\"\n", path);
}
if (false) {
SkSurface* surf = SkSurface::NewRasterPMColor(SkScalarCeilToInt(pic->cullRect().width()),
SkScalarCeilToInt(pic->cullRect().height()));
surf->getCanvas()->drawPicture(pic);
surf->unref();
}
if (false) { // re-record
SkPictureRecorder recorder;
pic->playback(recorder.beginRecording(pic->cullRect().width(),

17
src/core/SkCanvas.cpp
View File

@ -2529,6 +2529,23 @@ static bool supported_for_raster_canvas(const SkImageInfo& info) {
return true;
}
SkCanvas* SkCanvas::NewRaster(const SkImageInfo& info) {
if (!supported_for_raster_canvas(info)) {
return NULL;
}
SkBitmap bitmap;
if (!bitmap.tryAllocPixels(info)) {
return NULL;
}
// should this functionality be moved into allocPixels()?
if (!bitmap.info().isOpaque()) {
bitmap.eraseColor(0);
}
return SkNEW_ARGS(SkCanvas, (bitmap));
}
SkCanvas* SkCanvas::NewRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes) {
if (!supported_for_raster_canvas(info)) {
return NULL;

19
tests/CanvasTest.cpp
View File

@ -73,7 +73,7 @@ static void createBitmap(SkBitmap* bm, SkColor color) {
}
static SkSurface* createSurface(SkColor color) {
SkSurface* surface = SkSurface::NewRasterN32Premul(kWidth, kHeight);
SkSurface* surface = SkSurface::NewRasterPMColor(kWidth, kHeight);
surface->getCanvas()->clear(color);
return surface;
}
@ -748,13 +748,7 @@ static void TestOverrideStateConsistency(skiatest::Reporter* reporter, const Tes
static void test_newraster(skiatest::Reporter* reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
const size_t minRowBytes = info.minRowBytes();
const size_t size = info.getSafeSize(minRowBytes);
SkAutoMalloc storage(size);
SkPMColor* baseAddr = static_cast<SkPMColor*>(storage.get());
sk_bzero(baseAddr, size);
SkCanvas* canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
SkCanvas* canvas = SkCanvas::NewRaster(info);
REPORTER_ASSERT(reporter, canvas);
SkImageInfo info2;
@ -762,7 +756,6 @@ static void test_newraster(skiatest::Reporter* reporter) {
const SkPMColor* addr = (const SkPMColor*)canvas->peekPixels(&info2, &rowBytes);
REPORTER_ASSERT(reporter, addr);
REPORTER_ASSERT(reporter, info == info2);
REPORTER_ASSERT(reporter, minRowBytes == rowBytes);
for (int y = 0; y < info.height(); ++y) {
for (int x = 0; x < info.width(); ++x) {
REPORTER_ASSERT(reporter, 0 == addr[x]);
@ -773,19 +766,19 @@ static void test_newraster(skiatest::Reporter* reporter) {
// now try a deliberately bad info
info = info.makeWH(-1, info.height());
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRaster(info));
// too big
info = info.makeWH(1 << 30, 1 << 30);
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRaster(info));
// not a valid pixel type
info = SkImageInfo::Make(10, 10, kUnknown_SkColorType, info.alphaType());
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRaster(info));
// We should succeed with a zero-sized valid info
info = SkImageInfo::MakeN32Premul(0, 0);
canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
canvas = SkCanvas::NewRaster(info);
REPORTER_ASSERT(reporter, canvas);
SkDELETE(canvas);
}

16
tests/DeferredCanvasTest.cpp
View File

@ -32,7 +32,7 @@ static void create(SkBitmap* bm, SkColor color) {
}
static SkSurface* createSurface(SkColor color) {
SkSurface* surface = SkSurface::NewRasterN32Premul(gWidth, gHeight);
SkSurface* surface = SkSurface::NewRasterPMColor(gWidth, gHeight);
surface->getCanvas()->clear(color);
return surface;
}
@ -451,7 +451,7 @@ private:
// Verifies that the deferred canvas triggers a flush when its memory
// limit is exceeded
static void TestDeferredCanvasMemoryLimit(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
NotificationCounter notificationCounter;
@ -486,7 +486,7 @@ static void TestDeferredCanvasSilentFlush(skiatest::Reporter* reporter) {
}
static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
NotificationCounter notificationCounter;
@ -566,7 +566,7 @@ static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
}
static void TestDeferredCanvasSkip(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
NotificationCounter notificationCounter;
@ -585,7 +585,7 @@ static void TestDeferredCanvasBitmapShaderNoLeak(skiatest::Reporter* reporter) {
// This test covers a code path that inserts bitmaps into the bitmap heap through the
// flattening of SkBitmapProcShaders. The refcount in the bitmap heap is maintained through
// the flattening and unflattening of the shader.
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
// test will fail if nbIterations is not in sync with
// BITMAPS_TO_KEEP in SkGPipeWrite.cpp
@ -620,7 +620,7 @@ static void TestDeferredCanvasBitmapShaderNoLeak(skiatest::Reporter* reporter) {
}
static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkBitmap sourceImage;
// 100 by 100 image, takes 40,000 bytes in memory
@ -811,7 +811,7 @@ static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContext
}
static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
NotificationCounter notificationCounter;
@ -842,7 +842,7 @@ static void TestDeferredCanvasGetCanvasSize(skiatest::Reporter* reporter) {
SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
SkSurface* newSurface = SkSurface::NewRasterN32Premul(4, 4);
SkSurface* newSurface = SkSurface::NewRasterPMColor(4, 4);
SkAutoTUnref<SkSurface> aur(newSurface);
for (int i = 0; i < 2; ++i) {

2
tests/DrawBitmapRectTest.cpp
View File

@ -43,7 +43,7 @@ static void test_faulty_pixelref(skiatest::Reporter* reporter) {
REPORTER_ASSERT(reporter, installSuccess);
// now our bitmap has a pixelref, but we know it will fail to lock
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(200, 200));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(200, 200));
SkCanvas* canvas = surface->getCanvas();
const SkPaint::FilterLevel levels[] = {

48
tests/DrawPathTest.cpp
View File

@ -17,7 +17,7 @@ static void test_big_aa_rect(skiatest::Reporter* reporter) {
SkPMColor pixel[1];
output.installPixels(SkImageInfo::MakeN32Premul(1, 1), pixel, 4);
SkSurface* surf = SkSurface::NewRasterN32Premul(300, 33300);
SkSurface* surf = SkSurface::NewRasterPMColor(300, 33300);
SkCanvas* canvas = surf->getCanvas();
SkRect r = { 0, 33000, 300, 33300 };
@ -94,11 +94,11 @@ static void test_crbug131181() {
moveToH(&path, &data[0]);
cubicToH(&path, &data[2]);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(640, 480));
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(640, 480));
SkPaint paint;
paint.setAntiAlias(true);
surface->getCanvas()->drawPath(path, paint);
canvas->drawPath(path, paint);
}
// This used to assert in debug builds (and crash writing bad memory in release)
@ -125,36 +125,38 @@ static void test_crbug_140803() {
static void test_inversepathwithclip() {
SkPath path;
path.moveTo(0, 20);
path.quadTo(10, 10, 20, 20);
path.moveTo(0, SkIntToScalar(20));
path.quadTo(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(20), SkIntToScalar(20));
path.toggleInverseFillType();
SkPaint paint;
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(640, 480));
SkCanvas* canvas = surface->getCanvas();
canvas->save();
canvas->clipRect(SkRect::MakeWH(19, 11));
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(640, 480));
canvas.get()->save();
canvas.get()->clipRect(SkRect::MakeWH(SkIntToScalar(19), SkIntToScalar(11)));
paint.setAntiAlias(false);
canvas->drawPath(path, paint);
canvas.get()->drawPath(path, paint);
paint.setAntiAlias(true);
canvas->drawPath(path, paint);
canvas.get()->drawPath(path, paint);
canvas->restore();
canvas.get()->restore();
// Now do the test again, with the path flipped, so we only draw in the
// top half of our bounds, and have the clip intersect our bounds at the
// bottom.
path.reset(); // preserves our filltype
path.moveTo(0, 10);
path.quadTo(10, 20, 20, 10);
canvas->clipRect(SkRect::MakeXYWH(0, 19, 19, 11));
path.moveTo(0, SkIntToScalar(10));
path.quadTo(SkIntToScalar(10), SkIntToScalar(20),
SkIntToScalar(20), SkIntToScalar(10));
canvas.get()->clipRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(19),
SkIntToScalar(19), SkIntToScalar(11)));
paint.setAntiAlias(false);
canvas->drawPath(path, paint);
canvas.get()->drawPath(path, paint);
paint.setAntiAlias(true);
canvas->drawPath(path, paint);
canvas.get()->drawPath(path, paint);
}
static void test_bug533() {
@ -170,8 +172,8 @@ static void test_bug533() {
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(640, 480));
surface->getCanvas()->drawPath(path, paint);
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(640, 480));
canvas.get()->drawPath(path, paint);
}
static void test_crbug_140642() {
@ -212,8 +214,8 @@ static void test_bigcubic() {
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(640, 480));
surface->getCanvas()->drawPath(path, paint);
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(640, 480));
canvas.get()->drawPath(path, paint);
}
// we used to assert if the bounds of the device (clip) was larger than 32K
@ -222,13 +224,13 @@ static void test_bigcubic() {
static void test_giantaa() {
const int W = 400;
const int H = 400;
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(33000, 10));
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(33000, 10));
SkPaint paint;
paint.setAntiAlias(true);
SkPath path;
path.addOval(SkRect::MakeXYWH(-10, -10, 20 + W, 20 + H));
surface->getCanvas()->drawPath(path, paint);
canvas.get()->drawPath(path, paint);
}
// Extremely large path_length/dash_length ratios may cause infinite looping

10
tests/PathTest.cpp
View File

@ -54,7 +54,7 @@ static void make_path_crbug364224_simplified(SkPath* path) {
static void test_path_crbug364224() {
SkPath path;
SkPaint paint;
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(84, 88));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(84, 88));
SkCanvas* canvas = surface->getCanvas();
make_path_crbug364224_simplified(&path);
@ -299,7 +299,7 @@ static void test_bad_cubic_crbug234190() {
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(84, 88));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(84, 88));
surface->getCanvas()->drawPath(path, paint);
}
@ -418,7 +418,7 @@ static void test_crbug_170666() {
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(1000, 1000));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(1000, 1000));
build_path_simple_170666(path);
surface->getCanvas()->drawPath(path, paint);
@ -497,7 +497,7 @@ static void build_big_path(SkPath* path, bool reducedCase) {
}
static void test_clipped_cubic() {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(640, 480));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(640, 480));
// This path used to assert, because our cubic-chopping code incorrectly
// moved control points after the chop. This test should be run in SK_DEBUG
@ -533,7 +533,7 @@ static void test_tricky_cubic() {
SkPaint paint;
paint.setAntiAlias(true);
SkSurface* surface = SkSurface::NewRasterN32Premul(19, 130);
SkSurface* surface = SkSurface::NewRasterPMColor(19, 130);
surface->getCanvas()->drawPath(path, paint);
surface->unref();
}

2
tests/RecordDrawTest.cpp
View File

@ -286,7 +286,7 @@ DEF_TEST(RecordDraw_drawImage, r){
bool fDrawImageRectCalled;
};
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(10, 10));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(10, 10));
surface->getCanvas()->clear(SK_ColorGREEN);
SkAutoTUnref<SkImage> image(surface->newImageSnapshot());

2
tests/RecorderTest.cpp
View File

@ -155,7 +155,7 @@ DEF_TEST(Recorder_drawImage_takeReference, reporter) {
SkAutoTUnref<SkImage> image;
{
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
surface->getCanvas()->clear(SK_ColorGREEN);
image.reset(surface->newImageSnapshot());
}

5
tests/SkResourceCacheTest.cpp
View File

@ -11,7 +11,6 @@
#include "SkDiscardableMemoryPool.h"
#include "SkGraphics.h"
#include "SkResourceCache.h"
#include "SkSurface.h"
static const int kCanvasSize = 1;
static const int kBitmapSize = 16;
@ -28,8 +27,8 @@ static bool is_in_scaled_image_cache(const SkBitmap& orig,
// Draw a scaled bitmap, then return true iff it has been cached.
static bool test_scaled_image_cache_useage() {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(kCanvasSize, kCanvasSize));
SkCanvas* canvas = surface->getCanvas();
SkAutoTUnref<SkCanvas> canvas(
SkCanvas::NewRasterN32(kCanvasSize, kCanvasSize));
SkBitmap bitmap;
bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
bitmap.eraseColor(0xFFFFFFFF);

2
tools/skhello.cpp
View File

@ -33,7 +33,7 @@ static void doDraw(SkCanvas* canvas, const SkPaint& paint, const char text[]) {
static bool do_surface(int w, int h, const char path[], const char text[],
const SkPaint& paint) {
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(w, h));
SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(w, h));
doDraw(surface->getCanvas(), paint, text);
SkAutoTUnref<SkImage> image(surface->newImageSnapshot());