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

Finish the DDL sk_sp migration

Browse Source 
This will not be landed until chrome CL 2269958 lands.

Bug: skia:10425
Change-Id: I2a5081201ca3faed5232e8540086bd4c6f865767
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/299292
Commit-Queue: Adlai Holler <adlai@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
This commit is contained in:
Adlai Holler 2020-06-29 10:00:08 -04:00 committed by Skia Commit-Bot
parent 0851459813
commit f19bbb52b2
20 changed files with 29 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bench/DDLRecorderBench.cpp
View File

@ -81,7 +81,7 @@ private:
}
std::unique_ptr<SkDeferredDisplayListRecorder> fRecorder = nullptr;
std::vector<SkDDLPointer> fDDLs;
std::vector<sk_sp<SkDeferredDisplayList>> fDDLs;
typedef Benchmark INHERITED;
};

9
dm/DMSrcSink.cpp
View File

@ -1721,14 +1721,7 @@ Result GPUOOPRSink::ooprDraw(const Src& src,
iter.compile();
}
SkAssertResult(dstSurface->draw(ddl));
#ifdef SK_SP_IS_UNIQUE_POINTER
// TODO: remove this flush once DDLs are reffed by the drawing manager
context->flushAndSubmit();
#endif
ddl.reset();
SkAssertResult(dstSurface->draw(std::move(ddl)));
return Result::Ok();
}

4
docs/examples/Surface_characterize.cpp
View File

@ -23,9 +23,9 @@ void draw(SkCanvas* canvas) {
SkDeferredDisplayListRecorder recorder(characterization);
SkCanvas* subCanvas = recorder.getCanvas();
subCanvas->clear(SK_ColorGREEN);
std::unique_ptr<SkDeferredDisplayList> displayList = recorder.detach();
sk_sp<SkDeferredDisplayList> displayList = recorder.detach();
// end of threadable work
gpuSurface->draw(displayList.get());
gpuSurface->draw(displayList);
sk_sp<SkImage> img = gpuSurface->makeImageSnapshot();
canvas->drawImage(std::move(img), 0, 0);
}

4
docs/examples/Surface_draw_2.cpp
View File

@ -17,9 +17,9 @@ void draw(SkCanvas* canvas) {
SkDeferredDisplayListRecorder recorder(characterization);
SkCanvas* subCanvas = recorder.getCanvas();
subCanvas->clear(SK_ColorGREEN);
std::unique_ptr<SkDeferredDisplayList> displayList = recorder.detach();
sk_sp<SkDeferredDisplayList> displayList = recorder.detach();
// end of threadable work
gpuSurface->draw(displayList.get());
gpuSurface->draw(displayList);
sk_sp<SkImage> img = gpuSurface->makeImageSnapshot();
canvas->drawImage(std::move(img), 0, 0);
}

17
include/core/SkDeferredDisplayList.h
View File

@ -25,26 +25,11 @@ struct GrCCPerOpsTaskPaths;
using GrRenderTargetProxy = SkRefCnt;
#endif
class SkDeferredDisplayList;
// We are in the process of migrating DDL from unique_ptr to sk_sp. This macro can be defined
// by the user to keep the old API until they've migrated. It will be removed soon.
// This typedef is here temporarily and should not be used by the public.
#ifndef SK_DDL_IS_UNIQUE_POINTER
typedef sk_sp<SkDeferredDisplayList> SkDDLPointer;
#else
typedef std::unique_ptr<SkDeferredDisplayList> SkDDLPointer;
#endif
/*
* This class contains pre-processed gpu operations that can be replayed into
* an SkSurface via SkSurface::draw(SkDeferredDisplayList*).
*/
class SkDeferredDisplayList
#ifndef SK_DDL_IS_UNIQUE_POINTER
: public SkNVRefCnt<SkDeferredDisplayList>
#endif
{
class SkDeferredDisplayList : public SkNVRefCnt<SkDeferredDisplayList> {
public:
SK_API ~SkDeferredDisplayList();

2
include/core/SkDeferredDisplayListRecorder.h
View File

@ -50,7 +50,7 @@ public:
// Note: ownership of the SkCanvas is not transferred via this call.
SkCanvas* getCanvas();
SkDDLPointer detach();
sk_sp<SkDeferredDisplayList> detach();
using PromiseImageTextureContext = void*;
using PromiseImageTextureFulfillProc =

5
include/core/SkSurface.h
View File

@ -1046,12 +1046,7 @@ public:
example: https://fiddle.skia.org/c/@Surface_draw_2
*/
#ifndef SK_DDL_IS_UNIQUE_POINTER
bool draw(sk_sp<const SkDeferredDisplayList> deferredDisplayList);
#else
bool draw(const SkDeferredDisplayList* deferredDisplayList);
bool draw(const std::unique_ptr<const SkDeferredDisplayList>& deferredDisplayList);
#endif
protected:
SkSurface(int width, int height, const SkSurfaceProps* surfaceProps);

15
src/core/SkDeferredDisplayListRecorder.cpp
View File

@ -21,7 +21,7 @@ bool SkDeferredDisplayListRecorder::init() { return false; }
SkCanvas* SkDeferredDisplayListRecorder::getCanvas() { return nullptr; }
SkDDLPointer SkDeferredDisplayListRecorder::detach() { return nullptr; }
sk_sp<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() { return nullptr; }
sk_sp<SkImage> SkDeferredDisplayListRecorder::makePromiseTexture(
const GrBackendFormat& backendFormat,
@ -207,7 +207,7 @@ SkCanvas* SkDeferredDisplayListRecorder::getCanvas() {
return fSurface->getCanvas();
}
SkDDLPointer SkDeferredDisplayListRecorder::detach() {
sk_sp<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() {
if (!fContext) {
return nullptr;
}
@ -217,16 +217,17 @@ SkDDLPointer SkDeferredDisplayListRecorder::detach() {
canvas->restoreToCount(0);
}
SkDeferredDisplayList* ddl = new SkDeferredDisplayList(fCharacterization,
std::move(fTargetProxy),
std::move(fLazyProxyData));
fContext->priv().moveRenderTasksToDDL(ddl);
auto ddl = sk_sp<SkDeferredDisplayList>(new SkDeferredDisplayList(fCharacterization,
std::move(fTargetProxy),
std::move(fLazyProxyData)));
fContext->priv().moveRenderTasksToDDL(ddl.get());
// We want a new lazy proxy target for each recorded DDL so force the (lazy proxy-backed)
// SkSurface to be regenerated for each DDL.
fSurface = nullptr;
return SkDDLPointer(ddl);
return ddl;
}
sk_sp<SkImage> SkDeferredDisplayListRecorder::makePromiseTexture(

7
src/gpu/GrContextPriv.cpp
View File

@ -63,17 +63,10 @@ void GrContextPriv::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
fContext->drawingManager()->moveRenderTasksToDDL(ddl);
}
#ifndef SK_DDL_IS_UNIQUE_POINTER
void GrContextPriv::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList> ddl,
GrRenderTargetProxy* newDest) {
fContext->drawingManager()->copyRenderTasksFromDDL(std::move(ddl), newDest);
}
#else
void GrContextPriv::copyRenderTasksFromDDL(const SkDeferredDisplayList* ddl,
GrRenderTargetProxy* newDest) {
fContext->drawingManager()->copyRenderTasksFromDDL(ddl, newDest);
}
#endif
bool GrContextPriv::compile(const GrProgramDesc& desc, const GrProgramInfo& info) {
GrGpu* gpu = this->getGpu();

4
src/gpu/GrContextPriv.h
View File

@ -121,11 +121,7 @@ public:
}
void moveRenderTasksToDDL(SkDeferredDisplayList*);
#ifndef SK_DDL_IS_UNIQUE_POINTER
void copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
#else
void copyRenderTasksFromDDL(const SkDeferredDisplayList*, GrRenderTargetProxy* newDest);
#endif
bool compile(const GrProgramDesc&, const GrProgramInfo&);

7
src/gpu/GrDrawingManager.cpp
View File

@ -648,13 +648,8 @@ void GrDrawingManager::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
SkDEBUGCODE(this->validate());
}
#ifndef SK_DDL_IS_UNIQUE_POINTER
void GrDrawingManager::copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList> ddl,
GrRenderTargetProxy* newDest) {
#else
void GrDrawingManager::copyRenderTasksFromDDL(const SkDeferredDisplayList* ddl,
GrRenderTargetProxy* newDest) {
#endif
SkDEBUGCODE(this->validate());
if (fActiveOpsTask) {
@ -690,11 +685,9 @@ void GrDrawingManager::copyRenderTasksFromDDL(const SkDeferredDisplayList* ddl,
fDAG.add(ddl->fRenderTasks);
#ifndef SK_DDL_IS_UNIQUE_POINTER
// Add a task to unref the DDL after flush.
GrRenderTask* unrefTask = fDAG.add(sk_make_sp<GrUnrefDDLTask>(std::move(ddl)));
unrefTask->makeClosed(*fContext->priv().caps());
#endif
SkDEBUGCODE(this->validate());
}

4
src/gpu/GrDrawingManager.h
View File

@ -119,11 +119,7 @@ public:
void setLastRenderTask(const GrSurfaceProxy*, GrRenderTask*);
void moveRenderTasksToDDL(SkDeferredDisplayList* ddl);
#ifndef SK_DDL_IS_UNIQUE_POINTER
void copyRenderTasksFromDDL(sk_sp<const SkDeferredDisplayList>, GrRenderTargetProxy* newDest);
#else
void copyRenderTasksFromDDL(const SkDeferredDisplayList*, GrRenderTargetProxy* newDest);
#endif
private:
// This class encapsulates maintenance and manipulation of the drawing manager's DAG of

3
src/gpu/GrUnrefDDLTask.h
View File

@ -8,8 +8,6 @@
#ifndef GrUnrefDDLTask_DEFINED
#define GrUnrefDDLTask_DEFINED
#ifndef SK_DDL_IS_UNIQUE_POINTER
#include "src/gpu/GrRenderTask.h"
/** When a DDL is played back, the drawing manager refs the DDL and adds one
@ -53,5 +51,4 @@ private:
sk_sp<const SkDeferredDisplayList> fDDL;
};
#endif // !SK_DDL_IS_UNIQUE_POINTER
#endif

11
src/image/SkSurface.cpp
View File

@ -377,18 +377,9 @@ bool SkSurface::isCompatible(const SkSurfaceCharacterization& characterization)
return asConstSB(this)->onIsCompatible(characterization);
}
#ifndef SK_DDL_IS_UNIQUE_POINTER
bool SkSurface::draw(sk_sp<const SkDeferredDisplayList> ddl) {
return asSB(this)->onDraw(ddl);
return asSB(this)->onDraw(std::move(ddl));
}
#else
bool SkSurface::draw(const SkDeferredDisplayList* ddl) {
return asSB(this)->onDraw(ddl);
}
bool SkSurface::draw(const std::unique_ptr<const SkDeferredDisplayList>& ddl) {
return asSB(this)->onDraw(ddl.get());
}
#endif
//////////////////////////////////////////////////////////////////////////////////////
#include "include/utils/SkNoDrawCanvas.h"

4
src/image/SkSurface_Base.h
View File

@ -125,11 +125,7 @@ public:
virtual bool onCharacterize(SkSurfaceCharacterization*) const { return false; }
virtual bool onIsCompatible(const SkSurfaceCharacterization&) const { return false; }
#ifndef SK_DDL_IS_UNIQUE_POINTER
virtual bool onDraw(sk_sp<const SkDeferredDisplayList>) { return false; }
#else
virtual bool onDraw(const SkDeferredDisplayList*) { return false; }
#endif
inline SkCanvas* getCachedCanvas();
inline sk_sp<SkImage> refCachedImage();

14
src/image/SkSurface_Gpu.cpp
View File

@ -333,7 +333,6 @@ bool SkSurface_Gpu::onIsCompatible(const SkSurfaceCharacterization& characteriza
characterization.surfaceProps() == rtc->surfaceProps();
}
#ifndef SK_DDL_IS_UNIQUE_POINTER
bool SkSurface_Gpu::onDraw(sk_sp<const SkDeferredDisplayList> ddl) {
if (!ddl || !this->isCompatible(ddl->characterization())) {
return false;
@ -345,19 +344,6 @@ bool SkSurface_Gpu::onDraw(sk_sp<const SkDeferredDisplayList> ddl) {
ctx->priv().copyRenderTasksFromDDL(std::move(ddl), rtc->asRenderTargetProxy());
return true;
}
#else
bool SkSurface_Gpu::onDraw(const SkDeferredDisplayList* ddl) {
if (!ddl || !this->isCompatible(ddl->characterization())) {
return false;
}
GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext();
GrContext* ctx = fDevice->context();
ctx->priv().copyRenderTasksFromDDL(ddl, rtc->asRenderTargetProxy());
return true;
}
#endif
///////////////////////////////////////////////////////////////////////////////

4
src/image/SkSurface_Gpu.h
View File

@ -58,11 +58,7 @@ public:
bool onCharacterize(SkSurfaceCharacterization*) const override;
bool onIsCompatible(const SkSurfaceCharacterization&) const override;
void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) override;
#ifndef SK_DDL_IS_UNIQUE_POINTER
bool onDraw(sk_sp<const SkDeferredDisplayList>) override;
#else
bool onDraw(const SkDeferredDisplayList*) override;
#endif
SkGpuDevice* getDevice() { return fDevice.get(); }

12
tests/DeferredDisplayListTest.cpp
View File

@ -166,7 +166,7 @@ public:
}
// Create a DDL whose characterization captures the current settings
SkDDLPointer createDDL(GrContext* context) const {
sk_sp<SkDeferredDisplayList> createDDL(GrContext* context) const {
SkSurfaceCharacterization c = this->createCharacterization(context);
SkAssertResult(c.isValid());
@ -335,7 +335,7 @@ void DDLSurfaceCharacterizationTestImpl(GrContext* context, skiatest::Reporter*
SkBitmap bitmap;
bitmap.allocPixels(imageInfo);
SkDDLPointer ddl;
sk_sp<SkDeferredDisplayList> ddl;
// First, create a DDL using the stock SkSurface parameters
{
@ -726,7 +726,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DDLNonTextureabilityTest, reporter, ctxInfo)
bitmap.allocPixels(imageInfo);
for (bool textureability : { true, false }) {
SkDDLPointer ddl;
sk_sp<SkDeferredDisplayList> ddl;
// First, create a DDL w/o textureability (and thus no mipmaps). TODO: once we have
// reusable DDLs, move this outside of the loop.
@ -1047,7 +1047,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DDLSkSurfaceFlush, reporter, ctxInfo) {
FulfillInfo fulfillInfo;
fulfillInfo.fTex = SkPromiseImageTexture::Make(backendTexture);
SkDDLPointer ddl;
sk_sp<SkDeferredDisplayList> ddl;
{
SkDeferredDisplayListRecorder recorder(characterization);
@ -1126,7 +1126,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DDLMultipleDDLs, reporter, ctxInfo) {
canvas1->save();
canvas1->clipRect(SkRect::MakeXYWH(8, 8, 16, 16));
SkDDLPointer ddl1 = recorder.detach();
sk_sp<SkDeferredDisplayList> ddl1 = recorder.detach();
SkCanvas* canvas2 = recorder.getCanvas();
@ -1134,7 +1134,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DDLMultipleDDLs, reporter, ctxInfo) {
p.setColor(SK_ColorGREEN);
canvas2->drawRect(SkRect::MakeWH(32, 32), p);
SkDDLPointer ddl2 = recorder.detach();
sk_sp<SkDeferredDisplayList> ddl2 = recorder.detach();
REPORTER_ASSERT(reporter, ddl1->priv().lazyProxyData());
REPORTER_ASSERT(reporter, ddl2->priv().lazyProxyData());

5
tools/DDLTileHelper.cpp
View File

@ -289,11 +289,6 @@ static void do_gpu_stuff(GrContext* context, DDLTileHelper::TileData* tile) {
tile->draw(context);
#ifdef SK_SP_IS_UNIQUE_POINTER
// TODO: remove this flush once DDLs are reffed by the drawing manager
context->flushAndSubmit();
#endif
tile->dropDDL();
}

12
tools/DDLTileHelper.h
View File

@ -87,12 +87,12 @@ public:
// after 'fDisplayList' has been flushed (bc it owns the proxy the DDL's destination
// trampoline points at).
// TODO: fix the ref-order so we don't need 'fTileSurface' here
sk_sp<SkSurface> fTileSurface;
sk_sp<SkSurface> fTileSurface;
sk_sp<SkPicture> fReconstitutedPicture;
SkTArray<sk_sp<SkImage>> fPromiseImages; // All the promise images in the
sk_sp<SkPicture> fReconstitutedPicture;
SkTArray<sk_sp<SkImage>> fPromiseImages; // All the promise images in the
// reconstituted picture
SkDDLPointer fDisplayList;
sk_sp<SkDeferredDisplayList> fDisplayList;
};
DDLTileHelper(GrContext* context,
@ -110,7 +110,7 @@ public:
// Create the DDL that will compose all the tile images into a final result.
void createComposeDDL();
const SkDDLPointer& composeDDL() const { return fComposeDDL; }
const sk_sp<SkDeferredDisplayList>& composeDDL() const { return fComposeDDL; }
void precompileAndDrawAllTiles(GrContext*);
@ -137,7 +137,7 @@ private:
int fNumDivisions; // number of tiles along a side
SkAutoTArray<TileData> fTiles; // 'fNumDivisions' x 'fNumDivisions'
SkDDLPointer fComposeDDL;
sk_sp<SkDeferredDisplayList> fComposeDDL;
const SkSurfaceCharacterization fDstCharacterization;
};