Move DDL and SkSurfaceCharacterization to include/private/chromium
This also renames them to be more clearly Ganesh-specific:
- SkDeferredDisplayList -> GrDeferredDisplayList
- SkDeferredDisplayListRecorder -> GrDeferredDisplayListRecorder
- SkSurfaceCharacterization -> GrSurfaceCharacterization
SkSurface::draw(sk_sp<GrDeferredDisplayList>...) has been moved
to a static function - skgpu::ganesh::DrawDDL. This was better than
re-writing the API to take a GrDeferredDisplayList* which would
require re-wrapping in a sk_sp to be passed into the deeper layers -
an error-prone and efficient strategy.
Shim headers are still around, as well as a shim over the old
SkSurface method until Chromium can be migrated.
This CL has no functional changes in how DDLs work, besides
removing the ability to specify an offset, which was not
implemented and there are no plans to do so.
Change-Id: Ibb263d6b90e3b3616ffd11c7a03b69e78dd02fe4
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/706017
Commit-Queue: Kevin Lubick <kjlubick@google.com>
Owners-Override: Kevin Lubick <kjlubick@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/BUILD.gn b/BUILD.gn
index 577dd00..34ca483 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -2321,6 +2321,7 @@
}
test_app("imgcvt") {
sources = [ "tools/imgcvt.cpp" ]
+ configs = [ ":our_vulkan_headers" ]
deps = [
":skia",
"modules/skcms",
diff --git a/bench/DDLRecorderBench.cpp b/bench/DDLRecorderBench.cpp
index 56077e1..d749811 100644
--- a/bench/DDLRecorderBench.cpp
+++ b/bench/DDLRecorderBench.cpp
@@ -10,15 +10,15 @@
#include "bench/Benchmark.h"
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/gpu/GrDirectContext.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
-static SkSurfaceCharacterization create_characterization(GrDirectContext* direct) {
+static GrSurfaceCharacterization create_characterization(GrDirectContext* direct) {
size_t maxResourceBytes = direct->getResourceCacheLimit();
if (!direct->colorTypeSupportedAsSurface(kRGBA_8888_SkColorType)) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
SkImageInfo ii = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
@@ -27,12 +27,12 @@
GrBackendFormat backendFormat = direct->defaultBackendFormat(kRGBA_8888_SkColorType,
GrRenderable::kYes);
if (!backendFormat.isValid()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
SkSurfaceProps props(0x0, kUnknown_SkPixelGeometry);
- SkSurfaceCharacterization c = direct->threadSafeProxy()->createCharacterization(
+ GrSurfaceCharacterization c = direct->threadSafeProxy()->createCharacterization(
maxResourceBytes, ii, backendFormat, 1,
kTopLeft_GrSurfaceOrigin, props, false);
return c;
@@ -75,9 +75,9 @@
return;
}
- SkSurfaceCharacterization c = create_characterization(context);
+ GrSurfaceCharacterization c = create_characterization(context);
- fRecorder = std::make_unique<SkDeferredDisplayListRecorder>(c);
+ fRecorder = std::make_unique<GrDeferredDisplayListRecorder>(c);
}
// We defer the clean up of the DDLs so it is done outside of the timing loop
@@ -85,8 +85,8 @@
fDDLs.clear();
}
- std::unique_ptr<SkDeferredDisplayListRecorder> fRecorder = nullptr;
- std::vector<sk_sp<SkDeferredDisplayList>> fDDLs;
+ std::unique_ptr<GrDeferredDisplayListRecorder> fRecorder = nullptr;
+ std::vector<sk_sp<GrDeferredDisplayList>> fDDLs;
using INHERITED = Benchmark;
};
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 081238e..1d7a612 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -11,7 +11,6 @@
#include "include/codec/SkCodec.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkDocument.h"
#include "include/core/SkExecutor.h"
#include "include/core/SkImageGenerator.h"
@@ -20,7 +19,6 @@
#include "include/core/SkSerialProcs.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/docs/SkPDFDocument.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrDirectContext.h"
@@ -30,6 +28,8 @@
#include "include/ports/SkImageGeneratorNDK.h"
#include "include/ports/SkImageGeneratorWIC.h"
#include "include/private/base/SkTLogic.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/utils/SkNullCanvas.h"
#include "include/utils/SkPaintFilterCanvas.h"
#include "modules/skcms/skcms.h"
@@ -1785,7 +1785,7 @@
// We have to do this here bc characterization can hit the SkGpuDevice's thread guard (i.e.,
// leaving it until the DDLTileHelper ctor will result in multiple threads trying to use the
// same context (this thread and the gpuThread - which will be uploading textures)).
- SkSurfaceCharacterization dstCharacterization;
+ GrSurfaceCharacterization dstCharacterization;
SkAssertResult(dstSurface->characterize(&dstCharacterization));
auto size = src.size();
@@ -1845,7 +1845,7 @@
// the tiles' rendering. Additionally, bc we're aliasing the tiles' backend textures,
// there is nothing in the DAG to automatically force the required order.
gpuTaskGroup->add([dstSurface, ddl = tiles.composeDDL()]() {
- dstSurface->draw(ddl);
+ skgpu::ganesh::DrawDDL(dstSurface, ddl);
});
// This should be the only explicit flush for the entire DDL draw.
diff --git a/docs/examples/Surface_characterize.cpp b/docs/examples/Surface_characterize.cpp
index c3e6f6c..5ec8e5d 100644
--- a/docs/examples/Surface_characterize.cpp
+++ b/docs/examples/Surface_characterize.cpp
@@ -13,18 +13,18 @@
}
sk_sp<SkSurface> gpuSurface = SkSurfaces::RenderTarget(
context, skgpu::Budgeted::kYes, SkImageInfo::MakeN32Premul(64, 64));
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
if (!gpuSurface->characterize(&characterization)) {
canvas->drawString("characterization unsupported", 20, 40, font, paint);
return;
}
// start of threadable work
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
SkCanvas* subCanvas = recorder.getCanvas();
subCanvas->clear(SK_ColorGREEN);
- sk_sp<SkDeferredDisplayList> displayList = recorder.detach();
+ sk_sp<GrDeferredDisplayList> displayList = recorder.detach();
// end of threadable work
- gpuSurface->draw(displayList);
+ skgpu::ganesh::DrawDDL(gpuSurface, displayList);
sk_sp<SkImage> img = gpuSurface->makeImageSnapshot();
canvas->drawImage(std::move(img), 0, 0);
}
diff --git a/docs/examples/Surface_draw_2.cpp b/docs/examples/Surface_draw_2.cpp
index a5c9cff..1012bde 100644
--- a/docs/examples/Surface_draw_2.cpp
+++ b/docs/examples/Surface_draw_2.cpp
@@ -8,16 +8,16 @@
SkPaint paint;
paint.setTextSize(16);
sk_sp<SkSurface> gpuSurface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(64, 64));
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
if (!gpuSurface->characterize(&characterization)) {
canvas->drawString("characterization unsupported", 20, 40, paint);
return;
}
// start of threadable work
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
SkCanvas* subCanvas = recorder.getCanvas();
subCanvas->clear(SK_ColorGREEN);
- sk_sp<SkDeferredDisplayList> displayList = recorder.detach();
+ sk_sp<GrDeferredDisplayList> displayList = recorder.detach();
// end of threadable work
gpuSurface->draw(displayList);
sk_sp<SkImage> img = gpuSurface->makeImageSnapshot();
diff --git a/fuzz/FuzzCreateDDL.cpp b/fuzz/FuzzCreateDDL.cpp
index 0e7aab9..ec9da26 100644
--- a/fuzz/FuzzCreateDDL.cpp
+++ b/fuzz/FuzzCreateDDL.cpp
@@ -6,13 +6,13 @@
*/
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkPaint.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "tools/gpu/GrContextFactory.h"
@@ -22,14 +22,14 @@
#include <tuple>
/**
- * The fuzzer aims to fuzz the use of SkDeferredDisplayList. It mainly consists of
+ * The fuzzer aims to fuzz the use of GrDeferredDisplayList. It mainly consists of
* three parts.
- * 1. In create_surface_characterization, (make_characterization) Create SkSurfaceCharacterization
+ * 1. In create_surface_characterization, (make_characterization) Create GrSurfaceCharacterization
* by using GrDirectContext of kGL_ContextType as it can be applied on all platform, and
* (make_surface) create a GPU backend surface of the same GrDirectContext
- * 2. (make_ddl) Create SkDeferredDisplayListRecorder from the SkSurfaceCharacterization, and test
+ * 2. (make_ddl) Create GrDeferredDisplayListRecorder from the GrSurfaceCharacterization, and test
* the recoder's corresponding canvas.
- * 3. (make_ddl, draw_ddl) Create SkDeferredDisplayList from the SkDeferredDisplayRecorder and draw
+ * 3. (make_ddl, draw_ddl) Create GrDeferredDisplayList from the SkDeferredDisplayRecorder and draw
* the ddl on a GPU backend surface.
*/
@@ -122,7 +122,7 @@
SkColorSpace::MakeRGB(skcmsFn, skcmsMat));
}
-static SkSurfaceCharacterization make_characterization(Fuzz* fuzz, GrDirectContext* dContext,
+static GrSurfaceCharacterization make_characterization(Fuzz* fuzz, GrDirectContext* dContext,
SkImageInfo& ii, SkColorType surfaceType,
GrSurfaceOrigin origin) {
if (!dContext->colorTypeSupportedAsSurface(surfaceType)) {
@@ -142,7 +142,7 @@
#ifdef SK_VULKAN
fuzz->nextEnum(&protect, GrProtected::kYes);
#endif
- SkSurfaceCharacterization c;
+ GrSurfaceCharacterization c;
size_t maxResourceBytes = dContext->getResourceCacheLimit();
c = dContext->threadSafeProxy()->createCharacterization(
maxResourceBytes, ii, backendFormat, kSampleCount,
@@ -156,9 +156,9 @@
return c;
}
-static sk_sp<SkDeferredDisplayList> make_ddl(Fuzz* fuzz, GrDirectContext* dContext,
- const SkSurfaceCharacterization& c) {
- SkDeferredDisplayListRecorder r(c);
+static sk_sp<GrDeferredDisplayList> make_ddl(Fuzz* fuzz, GrDirectContext* dContext,
+ const GrSurfaceCharacterization& c) {
+ GrDeferredDisplayListRecorder r(c);
SkCanvas* canvas = r.getCanvas();
if (!canvas) {
SkDebugf("Could not create canvas for backend %s", GrBackendApiToStr(dContext->backend()));
@@ -181,16 +181,16 @@
return surface;
}
-static bool draw_ddl(sk_sp<SkSurface> surface, sk_sp<SkDeferredDisplayList> ddl) {
- return surface->draw(std::move(ddl));
+static bool draw_ddl(sk_sp<SkSurface> surface, sk_sp<const GrDeferredDisplayList> ddl) {
+ return skgpu::ganesh::DrawDDL(surface, ddl);
}
-using SurfaceAndChar = std::tuple<sk_sp<SkSurface>, SkSurfaceCharacterization>;
+using SurfaceAndChar = std::tuple<sk_sp<SkSurface>, GrSurfaceCharacterization>;
static SurfaceAndChar create_surface_and_characterization(Fuzz* fuzz, GrDirectContext* dContext,
SkColorType surfaceType,
GrSurfaceOrigin origin) {
SkImageInfo ii = gen_fuzzed_imageinfo(fuzz, surfaceType);
- SkSurfaceCharacterization c = make_characterization(fuzz, dContext, ii, surfaceType, origin);
+ GrSurfaceCharacterization c = make_characterization(fuzz, dContext, ii, surfaceType, origin);
if (!c.isValid()) {
return {};
}
@@ -222,7 +222,7 @@
return;
}
- sk_sp<SkDeferredDisplayList> ddl = make_ddl(fuzz, dContext, c);
+ sk_sp<GrDeferredDisplayList> ddl = make_ddl(fuzz, dContext, c);
if (!ddl) {
SkDebugf("Could not create ddl %s", GrBackendApiToStr(dContext->backend()));
return;
diff --git a/fuzz/FuzzDDLThreading.cpp b/fuzz/FuzzDDLThreading.cpp
index 8e2b208..0671483 100644
--- a/fuzz/FuzzDDLThreading.cpp
+++ b/fuzz/FuzzDDLThreading.cpp
@@ -9,8 +9,6 @@
#include "fuzz/FuzzCommon.h"
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkExecutor.h"
#include "include/core/SkPromiseImageTexture.h"
#include "include/core/SkSize.h"
@@ -22,6 +20,8 @@
#include "include/private/base/SkMutex.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkThreadID.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
#include "src/core/SkTaskGroup.h"
#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
#include "tools/gpu/GrContextFactory.h"
@@ -112,7 +112,7 @@
GrDirectContext* fContext = nullptr;
AutoTArray<PromiseImageInfo> fPromiseImages{kPromiseImageCount};
sk_sp<SkSurface> fSurface;
- SkSurfaceCharacterization fSurfaceCharacterization;
+ GrSurfaceCharacterization fSurfaceCharacterization;
std::unique_ptr<SkExecutor> fGpuExecutor = SkExecutor::MakeFIFOThreadPool(1, false);
std::unique_ptr<SkExecutor> fRecordingExecutor =
SkExecutor::MakeFIFOThreadPool(kRecordingThreadCount, false);
@@ -253,7 +253,7 @@
void DDLFuzzer::recordAndPlayDDL() {
SkASSERT(!this->isOnGPUThread() && !this->isOnMainThread());
- SkDeferredDisplayListRecorder recorder(fSurfaceCharacterization);
+ GrDeferredDisplayListRecorder recorder(fSurfaceCharacterization);
SkCanvas* canvas = recorder.getCanvas();
// Draw promise images in a strip
for (int i = 0; i < kPromiseImagesPerDDL; i++) {
@@ -264,9 +264,9 @@
fPromiseImages[j].fDrawn = true;
canvas->drawImage(fPromiseImages[j].fImage, xOffset, 0);
}
- sk_sp<SkDeferredDisplayList> ddl = recorder.detach();
+ sk_sp<GrDeferredDisplayList> ddl = recorder.detach();
fGpuTaskGroup.add([=, ddl{std::move(ddl)}]{
- bool success = fSurface->draw(std::move(ddl));
+ bool success = skgpu::ganesh::DrawDDL(fSurface, std::move(ddl));
if (!success) {
fFuzz->signalBug();
}
diff --git a/gn/core.gni b/gn/core.gni
index cd75e90..10fb13b 100644
--- a/gn/core.gni
+++ b/gn/core.gni
@@ -328,9 +328,6 @@
"$_src/core/SkDataTable.cpp",
"$_src/core/SkDebug.cpp",
"$_src/core/SkDebugUtils.h",
- "$_src/core/SkDeferredDisplayList.cpp",
- "$_src/core/SkDeferredDisplayListPriv.h",
- "$_src/core/SkDeferredDisplayListRecorder.cpp",
"$_src/core/SkDescriptor.cpp",
"$_src/core/SkDescriptor.h",
"$_src/core/SkDevice.cpp",
@@ -547,7 +544,6 @@
"$_src/core/SkStrokeRec.cpp",
"$_src/core/SkStrokerPriv.cpp",
"$_src/core/SkStrokerPriv.h",
- "$_src/core/SkSurfaceCharacterization.cpp",
"$_src/core/SkSurfacePriv.h",
"$_src/core/SkSwizzle.cpp",
"$_src/core/SkSwizzlePriv.h",
diff --git a/gn/gpu.gni b/gn/gpu.gni
index a8b1882..a860076 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -172,6 +172,9 @@
"$_src/gpu/ganesh/GrDataUtils.h",
"$_src/gpu/ganesh/GrDefaultGeoProcFactory.cpp",
"$_src/gpu/ganesh/GrDefaultGeoProcFactory.h",
+ "$_src/gpu/ganesh/GrDeferredDisplayList.cpp",
+ "$_src/gpu/ganesh/GrDeferredDisplayListPriv.h",
+ "$_src/gpu/ganesh/GrDeferredDisplayListRecorder.cpp",
"$_src/gpu/ganesh/GrDeferredProxyUploader.h",
"$_src/gpu/ganesh/GrDeferredUpload.h",
"$_src/gpu/ganesh/GrDirectContext.cpp",
@@ -296,6 +299,7 @@
"$_src/gpu/ganesh/GrStyle.h",
"$_src/gpu/ganesh/GrSurface.cpp",
"$_src/gpu/ganesh/GrSurface.h",
+ "$_src/gpu/ganesh/GrSurfaceCharacterization.cpp",
"$_src/gpu/ganesh/GrSurfaceInfo.cpp",
"$_src/gpu/ganesh/GrSurfaceProxy.cpp",
"$_src/gpu/ganesh/GrSurfaceProxy.h",
@@ -567,7 +571,12 @@
]
# Generated by Bazel rule //include/private/chromium:gpu_private_hdrs
-skia_gpu_chromium_public = [ "$_include/private/chromium/GrSlug.h" ]
+skia_gpu_chromium_public = [
+ "$_include/private/chromium/GrDeferredDisplayList.h",
+ "$_include/private/chromium/GrDeferredDisplayListRecorder.h",
+ "$_include/private/chromium/GrSlug.h",
+ "$_include/private/chromium/GrSurfaceCharacterization.h",
+]
# Generated by Bazel rule //include/gpu/gl:public_hdrs
skia_gpu_gl_public = [
diff --git a/include/core/BUILD.bazel b/include/core/BUILD.bazel
index a4636bf..3d364d2 100644
--- a/include/core/BUILD.bazel
+++ b/include/core/BUILD.bazel
@@ -40,8 +40,8 @@
"SkCubicMap.h",
"SkData.h",
"SkDataTable.h",
- "SkDeferredDisplayList.h",
- "SkDeferredDisplayListRecorder.h",
+ "SkDeferredDisplayList.h", # TODO(kjlubick) remove this shim
+ "SkDeferredDisplayListRecorder.h", # TODO(kjlubick) remove this shim
"SkDocument.h",
"SkDrawable.h",
"SkEncodedImageFormat.h", # TODO(kjlubick) remove this shim
@@ -96,7 +96,7 @@
"SkString.h",
"SkStrokeRec.h",
"SkSurface.h",
- "SkSurfaceCharacterization.h",
+ "SkSurfaceCharacterization.h", # TODO(kjlubick) remove this shim
"SkSurfaceProps.h",
"SkSwizzle.h",
"SkTextBlob.h",
diff --git a/include/core/SkDeferredDisplayList.h b/include/core/SkDeferredDisplayList.h
index e5511be..37a1486 100644
--- a/include/core/SkDeferredDisplayList.h
+++ b/include/core/SkDeferredDisplayList.h
@@ -5,107 +5,11 @@
* found in the LICENSE file.
*/
-#ifndef SkDeferredDisplayList_DEFINED
-#define SkDeferredDisplayList_DEFINED
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location and name
+#include "include/private/chromium/GrDeferredDisplayList.h" // IWYU pragma: export
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceCharacterization.h"
-#include "include/core/SkTypes.h"
-
-class SkDeferredDisplayListPriv;
-class SkPromiseImageTexture;
-
-#if defined(SK_GANESH)
-#include "include/gpu/GrRecordingContext.h"
-#include "include/private/base/SkTArray.h"
-#include <map>
-class GrRenderTask;
-class GrRenderTargetProxy;
-#else
-using GrRenderTargetProxy = SkRefCnt;
-#endif
-
-/*
- * This class contains pre-processed gpu operations that can be replayed into
- * an SkSurface via SkSurface::draw(SkDeferredDisplayList*).
- */
-class SkDeferredDisplayList : public SkNVRefCnt<SkDeferredDisplayList> {
-public:
- SK_API ~SkDeferredDisplayList();
-
- SK_API const SkSurfaceCharacterization& characterization() const {
- return fCharacterization;
- }
-
-#if defined(SK_GANESH)
- /**
- * Iterate through the programs required by the DDL.
- */
- class SK_API ProgramIterator {
- public:
- ProgramIterator(GrDirectContext*, SkDeferredDisplayList*);
- ~ProgramIterator();
-
- // This returns true if any work was done. Getting a cache hit does not count as work.
- bool compile();
- bool done() const;
- void next();
-
- private:
- GrDirectContext* fDContext;
- const skia_private::TArray<GrRecordingContext::ProgramData>& fProgramData;
- int fIndex;
- };
-#endif
-
- // Provides access to functions that aren't part of the public API.
- SkDeferredDisplayListPriv priv();
- const SkDeferredDisplayListPriv priv() const; // NOLINT(readability-const-return-type)
-
-private:
- friend class GrDrawingManager; // for access to 'fRenderTasks', 'fLazyProxyData', 'fArenas'
- friend class SkDeferredDisplayListRecorder; // for access to 'fLazyProxyData'
- friend class SkDeferredDisplayListPriv;
-
- // This object is the source from which the lazy proxy backing the DDL will pull its backing
- // texture when the DDL is replayed. It has to be separately ref counted bc the lazy proxy
- // can outlive the DDL.
- class LazyProxyData : public SkRefCnt {
-#if defined(SK_GANESH)
- public:
- // Upon being replayed - this field will be filled in (by the DrawingManager) with the
- // proxy backing the destination SkSurface. Note that, since there is no good place to
- // clear it, it can become a dangling pointer. Additionally, since the renderTargetProxy
- // doesn't get a ref here, the SkSurface that owns it must remain alive until the DDL
- // is flushed.
- // TODO: the drawing manager could ref the renderTargetProxy for the DDL and then add
- // a renderingTask to unref it after the DDL's ops have been executed.
- GrRenderTargetProxy* fReplayDest = nullptr;
-#endif
- };
-
- SK_API SkDeferredDisplayList(const SkSurfaceCharacterization& characterization,
- sk_sp<GrRenderTargetProxy> fTargetProxy,
- sk_sp<LazyProxyData>);
-
-#if defined(SK_GANESH)
- const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
- return fProgramData;
- }
-#endif
-
- const SkSurfaceCharacterization fCharacterization;
-
-#if defined(SK_GANESH)
- // These are ordered such that the destructor cleans op tasks up first (which may refer back
- // to the arena and memory pool in their destructors).
- GrRecordingContext::OwnedArenas fArenas;
- skia_private::TArray<sk_sp<GrRenderTask>> fRenderTasks;
-
- skia_private::TArray<GrRecordingContext::ProgramData> fProgramData;
- sk_sp<GrRenderTargetProxy> fTargetProxy;
- sk_sp<LazyProxyData> fLazyProxyData;
-#endif
-};
-
-#endif
+class GrDeferredDisplayListRecorder;
+class GrSurfaceCharacterization;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;
diff --git a/include/core/SkDeferredDisplayListRecorder.h b/include/core/SkDeferredDisplayListRecorder.h
index cd91798..cee8a02 100644
--- a/include/core/SkDeferredDisplayListRecorder.h
+++ b/include/core/SkDeferredDisplayListRecorder.h
@@ -5,94 +5,11 @@
* found in the LICENSE file.
*/
-#ifndef SkDeferredDisplayListRecorder_DEFINED
-#define SkDeferredDisplayListRecorder_DEFINED
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h" // IWYU pragma: export
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkImage.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceCharacterization.h"
-#include "include/core/SkTypes.h"
-
-class GrBackendFormat;
-class GrBackendTexture;
-class GrRecordingContext;
-class GrYUVABackendTextureInfo;
-class SkCanvas;
-class SkSurface;
-
-/*
- * This class is intended to be used as:
- * Get an SkSurfaceCharacterization representing the intended gpu-backed destination SkSurface
- * Create one of these (an SkDeferredDisplayListRecorder) on the stack
- * Get the canvas and render into it
- * Snap off and hold on to an SkDeferredDisplayList
- * Once your app actually needs the pixels, call SkSurface::draw(SkDeferredDisplayList*)
- *
- * This class never accesses the GPU but performs all the cpu work it can. It
- * is thread-safe (i.e., one can break a scene into tiles and perform their cpu-side
- * work in parallel ahead of time).
- */
-class SK_API SkDeferredDisplayListRecorder {
-public:
- SkDeferredDisplayListRecorder(const SkSurfaceCharacterization&);
- ~SkDeferredDisplayListRecorder();
-
- const SkSurfaceCharacterization& characterization() const {
- return fCharacterization;
- }
-
- // The backing canvas will become invalid (and this entry point will return
- // null) once 'detach' is called.
- // Note: ownership of the SkCanvas is not transferred via this call.
- SkCanvas* getCanvas();
-
- sk_sp<SkDeferredDisplayList> detach();
-
-#if defined(SK_GANESH)
- using PromiseImageTextureContext = void*;
- using PromiseImageTextureFulfillProc =
- sk_sp<SkPromiseImageTexture> (*)(PromiseImageTextureContext);
- using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
-
-#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
- /** Deprecated: Use SkImages::PromiseTextureFrom instead. */
- sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
- int width,
- int height,
- GrMipmapped mipmapped,
- GrSurfaceOrigin origin,
- SkColorType colorType,
- SkAlphaType alphaType,
- sk_sp<SkColorSpace> colorSpace,
- PromiseImageTextureFulfillProc textureFulfillProc,
- PromiseImageTextureReleaseProc textureReleaseProc,
- PromiseImageTextureContext textureContext);
-
- /** Deprecated: Use SkImages::PromiseTextureFromYUVA instead. */
- sk_sp<SkImage> makeYUVAPromiseTexture(const GrYUVABackendTextureInfo& yuvaBackendTextureInfo,
- sk_sp<SkColorSpace> imageColorSpace,
- PromiseImageTextureFulfillProc textureFulfillProc,
- PromiseImageTextureReleaseProc textureReleaseProc,
- PromiseImageTextureContext textureContexts[]);
-#endif // SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-#endif // defined(SK_GANESH)
-
-private:
- SkDeferredDisplayListRecorder(const SkDeferredDisplayListRecorder&) = delete;
- SkDeferredDisplayListRecorder& operator=(const SkDeferredDisplayListRecorder&) = delete;
-
- bool init();
-
- const SkSurfaceCharacterization fCharacterization;
-
-#if defined(SK_GANESH)
- sk_sp<GrRecordingContext> fContext;
- sk_sp<GrRenderTargetProxy> fTargetProxy;
- sk_sp<SkDeferredDisplayList::LazyProxyData> fLazyProxyData;
- sk_sp<SkSurface> fSurface;
-#endif
-};
-
-#endif
+class GrDeferredDisplayList;
+class GrSurfaceCharacterization;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;
diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h
index f1579f1..b5baef8 100644
--- a/include/core/SkSurface.h
+++ b/include/core/SkSurface.h
@@ -23,16 +23,16 @@
class GrBackendSemaphore;
class GrBackendTexture;
+class GrDeferredDisplayList;
class GrRecordingContext;
+class GrSurfaceCharacterization;
+enum GrSurfaceOrigin : int;
class SkBitmap;
class SkCanvas;
class SkCapabilities;
class SkColorSpace;
-class SkDeferredDisplayList;
class SkPaint;
class SkSurface;
-class SkSurfaceCharacterization;
-enum GrSurfaceOrigin : int;
struct SkIRect;
struct SkISize;
@@ -170,13 +170,13 @@
/** Is this surface compatible with the provided characterization?
This method can be used to determine if an existing SkSurface is a viable destination
- for an SkDeferredDisplayList.
+ for an GrDeferredDisplayList.
@param characterization The characterization for which a compatibility check is desired
@return true if this surface is compatible with the characterization;
false otherwise
*/
- bool isCompatible(const SkSurfaceCharacterization& characterization) const;
+ bool isCompatible(const GrSurfaceCharacterization& characterization) const;
/** Returns pixel count in each row; may be zero or greater.
@@ -614,9 +614,9 @@
bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
bool deleteSemaphoresAfterWait = true);
- /** Initializes SkSurfaceCharacterization that can be used to perform GPU back-end
+ /** Initializes GrSurfaceCharacterization that can be used to perform GPU back-end
processing in a separate thread. Typically this is used to divide drawing
- into multiple tiles. SkDeferredDisplayListRecorder records the drawing commands
+ into multiple tiles. GrDeferredDisplayListRecorder records the drawing commands
for each tile.
Return true if SkSurface supports characterization. raster surface returns false.
@@ -626,27 +626,7 @@
example: https://fiddle.skia.org/c/@Surface_characterize
*/
- bool characterize(SkSurfaceCharacterization* characterization) const;
-
- /** Draws the deferred display list created via a SkDeferredDisplayListRecorder.
- If the deferred display list is not compatible with this SkSurface, the draw is skipped
- and false is return.
-
- The xOffset and yOffset parameters are experimental and, if not both zero, will cause
- the draw to be ignored.
- When implemented, if xOffset or yOffset are non-zero, the DDL will be drawn offset by that
- amount into the surface.
-
- @param deferredDisplayList drawing commands
- @param xOffset x-offset at which to draw the DDL
- @param yOffset y-offset at which to draw the DDL
- @return false if deferredDisplayList is not compatible
-
- example: https://fiddle.skia.org/c/@Surface_draw_2
- */
- bool draw(sk_sp<const SkDeferredDisplayList> deferredDisplayList,
- int xOffset = 0,
- int yOffset = 0);
+ bool characterize(GrSurfaceCharacterization* characterization) const;
protected:
SkSurface(int width, int height, const SkSurfaceProps* surfaceProps);
@@ -683,6 +663,12 @@
sk_sp<SkImage> asImage();
#endif
+#if !defined(SK_DISABLE_LEGACY_SKSURFACE_DISPLAYLIST)
+ bool draw(sk_sp<const GrDeferredDisplayList> deferredDisplayList,
+ int xOffset = 0,
+ int yOffset = 0);
+#endif
+
};
#endif
diff --git a/include/core/SkSurfaceCharacterization.h b/include/core/SkSurfaceCharacterization.h
index 0b65a10..35b284d 100644
--- a/include/core/SkSurfaceCharacterization.h
+++ b/include/core/SkSurfaceCharacterization.h
@@ -5,259 +5,11 @@
* found in the LICENSE file.
*/
-#ifndef SkSurfaceCharacterization_DEFINED
-#define SkSurfaceCharacterization_DEFINED
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location and name
+#include "include/private/chromium/GrSurfaceCharacterization.h" // IWYU pragma: export
-
-#include "include/core/SkColorSpace.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceProps.h"
-
-class SkColorSpace;
-
-
-#if defined(SK_GANESH)
-#include "include/gpu/GrBackendSurface.h"
-#include "include/gpu/GrContextThreadSafeProxy.h"
-#include "include/gpu/GrTypes.h"
-
-/** \class SkSurfaceCharacterization
- A surface characterization contains all the information Ganesh requires to makes its internal
- rendering decisions. When passed into a SkDeferredDisplayListRecorder it will copy the
- data and pass it on to the SkDeferredDisplayList if/when it is created. Note that both of
- those objects (the Recorder and the DisplayList) will take a ref on the
- GrContextThreadSafeProxy and SkColorSpace objects.
-*/
-class SK_API SkSurfaceCharacterization {
-public:
- enum class Textureable : bool { kNo = false, kYes = true };
- enum class MipMapped : bool { kNo = false, kYes = true };
- enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
- // This flag indicates that the backing VkImage for this Vulkan surface will have the
- // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
- // more optimally in a shader by being able to directly read the dst values.
- enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true };
- // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer.
- enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true };
-
- SkSurfaceCharacterization()
- : fCacheMaxResourceBytes(0)
- , fOrigin(kBottomLeft_GrSurfaceOrigin)
- , fSampleCnt(0)
- , fIsTextureable(Textureable::kYes)
- , fIsMipMapped(MipMapped::kYes)
- , fUsesGLFBO0(UsesGLFBO0::kNo)
- , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
- , fIsProtected(GrProtected::kNo)
- , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
- }
-
- SkSurfaceCharacterization(SkSurfaceCharacterization&&) = default;
- SkSurfaceCharacterization& operator=(SkSurfaceCharacterization&&) = default;
-
- SkSurfaceCharacterization(const SkSurfaceCharacterization&) = default;
- SkSurfaceCharacterization& operator=(const SkSurfaceCharacterization& other) = default;
- bool operator==(const SkSurfaceCharacterization& other) const;
- bool operator!=(const SkSurfaceCharacterization& other) const {
- return !(*this == other);
- }
-
- /*
- * Return a new surface characterization with the only difference being a different width
- * and height
- */
- SkSurfaceCharacterization createResized(int width, int height) const;
-
- /*
- * Return a new surface characterization with only a replaced color space
- */
- SkSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const;
-
- /*
- * Return a new surface characterization with the backend format replaced. A colorType
- * must also be supplied to indicate the interpretation of the new format.
- */
- SkSurfaceCharacterization createBackendFormat(SkColorType colorType,
- const GrBackendFormat& backendFormat) const;
-
- /*
- * Return a new surface characterization with just a different use of FBO0 (in GL)
- */
- SkSurfaceCharacterization createFBO0(bool usesGLFBO0) const;
-
- GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
- sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; }
- size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
-
- bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); }
-
- const SkImageInfo& imageInfo() const { return fImageInfo; }
- const GrBackendFormat& backendFormat() const { return fBackendFormat; }
- GrSurfaceOrigin origin() const { return fOrigin; }
- SkISize dimensions() const { return fImageInfo.dimensions(); }
- int width() const { return fImageInfo.width(); }
- int height() const { return fImageInfo.height(); }
- SkColorType colorType() const { return fImageInfo.colorType(); }
- int sampleCount() const { return fSampleCnt; }
- bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
- bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
- bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
- bool vkRTSupportsInputAttachment() const {
- return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
- }
- bool vulkanSecondaryCBCompatible() const {
- return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
- }
- GrProtected isProtected() const { return fIsProtected; }
- SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
- sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
- const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
-
- // Is the provided backend texture compatible with this surface characterization?
- bool isCompatible(const GrBackendTexture&) const;
-
-private:
- friend class SkSurface_Ganesh; // for 'set' & 'config'
- friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
- friend class GrContextThreadSafeProxy; // for private ctor
- friend class SkDeferredDisplayListRecorder; // for 'config'
- friend class SkSurface; // for 'config'
-
- SkDEBUGCODE(void validate() const;)
-
- SkSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
- size_t cacheMaxResourceBytes,
- const SkImageInfo& ii,
- const GrBackendFormat& backendFormat,
- GrSurfaceOrigin origin,
- int sampleCnt,
- Textureable isTextureable,
- MipMapped isMipMapped,
- UsesGLFBO0 usesGLFBO0,
- VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
- VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
- GrProtected isProtected,
- const SkSurfaceProps& surfaceProps)
- : fContextInfo(std::move(contextInfo))
- , fCacheMaxResourceBytes(cacheMaxResourceBytes)
- , fImageInfo(ii)
- , fBackendFormat(backendFormat)
- , fOrigin(origin)
- , fSampleCnt(sampleCnt)
- , fIsTextureable(isTextureable)
- , fIsMipMapped(isMipMapped)
- , fUsesGLFBO0(usesGLFBO0)
- , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
- , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
- , fIsProtected(isProtected)
- , fSurfaceProps(surfaceProps) {
- if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
- // Dynamic MSAA is not currently supported with DDL.
- *this = {};
- }
- SkDEBUGCODE(this->validate());
- }
-
- void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
- size_t cacheMaxResourceBytes,
- const SkImageInfo& ii,
- const GrBackendFormat& backendFormat,
- GrSurfaceOrigin origin,
- int sampleCnt,
- Textureable isTextureable,
- MipMapped isMipMapped,
- UsesGLFBO0 usesGLFBO0,
- VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
- VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
- GrProtected isProtected,
- const SkSurfaceProps& surfaceProps) {
- if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
- // Dynamic MSAA is not currently supported with DDL.
- *this = {};
- } else {
- fContextInfo = contextInfo;
- fCacheMaxResourceBytes = cacheMaxResourceBytes;
-
- fImageInfo = ii;
- fBackendFormat = backendFormat;
- fOrigin = origin;
- fSampleCnt = sampleCnt;
- fIsTextureable = isTextureable;
- fIsMipMapped = isMipMapped;
- fUsesGLFBO0 = usesGLFBO0;
- fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
- fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
- fIsProtected = isProtected;
- fSurfaceProps = surfaceProps;
- }
- SkDEBUGCODE(this->validate());
- }
-
- sk_sp<GrContextThreadSafeProxy> fContextInfo;
- size_t fCacheMaxResourceBytes;
-
- SkImageInfo fImageInfo;
- GrBackendFormat fBackendFormat;
- GrSurfaceOrigin fOrigin;
- int fSampleCnt;
- Textureable fIsTextureable;
- MipMapped fIsMipMapped;
- UsesGLFBO0 fUsesGLFBO0;
- VkRTSupportsInputAttachment fVkRTSupportsInputAttachment;
- VulkanSecondaryCBCompatible fVulkanSecondaryCBCompatible;
- GrProtected fIsProtected;
- SkSurfaceProps fSurfaceProps;
-};
-
-#else// !defined(SK_GANESH)
-class GrBackendFormat;
-
-class SK_API SkSurfaceCharacterization {
-public:
- SkSurfaceCharacterization() : fSurfaceProps(0, kUnknown_SkPixelGeometry) { }
-
- SkSurfaceCharacterization createResized(int width, int height) const {
- return *this;
- }
-
- SkSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const {
- return *this;
- }
-
- SkSurfaceCharacterization createBackendFormat(SkColorType, const GrBackendFormat&) const {
- return *this;
- }
-
- SkSurfaceCharacterization createFBO0(bool usesGLFBO0) const {
- return *this;
- }
-
- bool operator==(const SkSurfaceCharacterization& other) const { return false; }
- bool operator!=(const SkSurfaceCharacterization& other) const {
- return !(*this == other);
- }
-
- size_t cacheMaxResourceBytes() const { return 0; }
-
- bool isValid() const { return false; }
-
- int width() const { return 0; }
- int height() const { return 0; }
- int stencilCount() const { return 0; }
- bool isTextureable() const { return false; }
- bool isMipMapped() const { return false; }
- bool usesGLFBO0() const { return false; }
- bool vkRTSupportsAttachmentInput() const { return false; }
- bool vulkanSecondaryCBCompatible() const { return false; }
- SkColorSpace* colorSpace() const { return nullptr; }
- sk_sp<SkColorSpace> refColorSpace() const { return nullptr; }
- const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
-
-private:
- SkSurfaceProps fSurfaceProps;
-};
-
-#endif
-
-#endif
+class GrDeferredDisplayList;
+class GrDeferredDisplayListRecorder;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;
diff --git a/include/gpu/GrBackendSurface.h b/include/gpu/GrBackendSurface.h
index fe02032..eaafb98 100644
--- a/include/gpu/GrBackendSurface.h
+++ b/include/gpu/GrBackendSurface.h
@@ -62,7 +62,7 @@
#if !defined(SK_GANESH)
-// SkSurfaceCharacterization always needs a minimal version of this
+// GrSurfaceCharacterization always needs a minimal version of this
class SK_API GrBackendFormat {
public:
bool isValid() const { return false; }
diff --git a/include/gpu/GrContextThreadSafeProxy.h b/include/gpu/GrContextThreadSafeProxy.h
index eb75555..8e46b60 100644
--- a/include/gpu/GrContextThreadSafeProxy.h
+++ b/include/gpu/GrContextThreadSafeProxy.h
@@ -22,9 +22,9 @@
class GrBackendFormat;
class GrCaps;
class GrContextThreadSafeProxyPriv;
+class GrSurfaceCharacterization;
class GrThreadSafeCache;
class GrThreadSafePipelineBuilder;
-class SkSurfaceCharacterization;
class SkSurfaceProps;
enum class SkTextureCompressionType;
@@ -85,7 +85,7 @@
* willUseGLFBO0 = false
* vkRTSupportsInputAttachment = false
*/
- SkSurfaceCharacterization createCharacterization(
+ GrSurfaceCharacterization createCharacterization(
size_t cacheMaxResourceBytes,
const SkImageInfo& ii,
const GrBackendFormat& backendFormat,
@@ -102,7 +102,7 @@
/*
* Retrieve the default GrBackendFormat for a given SkColorType and renderability.
* It is guaranteed that this backend format will be the one used by the following
- * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+ * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
*
* The caller should check that the returned format is valid.
*/
diff --git a/include/gpu/GrDirectContext.h b/include/gpu/GrDirectContext.h
index 286e330..65287f9 100644
--- a/include/gpu/GrDirectContext.h
+++ b/include/gpu/GrDirectContext.h
@@ -544,7 +544,7 @@
/**
* Retrieve the default GrBackendFormat for a given SkColorType and renderability.
* It is guaranteed that this backend format will be the one used by the following
- * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+ * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
*
* The caller should check that the returned format is valid.
*/
diff --git a/include/gpu/GrRecordingContext.h b/include/gpu/GrRecordingContext.h
index 574afe1..ec3cf32 100644
--- a/include/gpu/GrRecordingContext.h
+++ b/include/gpu/GrRecordingContext.h
@@ -119,8 +119,8 @@
protected:
friend class GrRecordingContextPriv; // for hidden functions
- friend class SkDeferredDisplayList; // for OwnedArenas
- friend class SkDeferredDisplayListPriv; // for ProgramData
+ friend class GrDeferredDisplayList; // for OwnedArenas
+ friend class GrDeferredDisplayListPriv; // for ProgramData
// Like Arenas, but preserves ownership of the underlying pools.
class OwnedArenas {
diff --git a/include/gpu/ganesh/SkImageGanesh.h b/include/gpu/ganesh/SkImageGanesh.h
index b6723d0..bb295a2 100644
--- a/include/gpu/ganesh/SkImageGanesh.h
+++ b/include/gpu/ganesh/SkImageGanesh.h
@@ -273,7 +273,7 @@
image does not require access to the backend API or GrDirectContext. Instead of passing a
GrBackendTexture the client supplies a description of the texture consisting of
GrBackendFormat, width, height, and GrMipmapped state. The resulting SkImage can be drawn
- to a SkDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
+ to a GrDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
When the actual texture is required to perform a backend API draw, textureFulfillProc will
be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
those set during the SkImage creation, and it must refer to a valid existing texture in the
diff --git a/include/gpu/ganesh/SkSurfaceGanesh.h b/include/gpu/ganesh/SkSurfaceGanesh.h
index f67f591..4ee29b70 100644
--- a/include/gpu/ganesh/SkSurfaceGanesh.h
+++ b/include/gpu/ganesh/SkSurfaceGanesh.h
@@ -18,7 +18,7 @@
class GrBackendTexture;
class GrRecordingContext;
class SkColorSpace;
-class SkSurfaceCharacterization;
+class GrSurfaceCharacterization;
class SkSurfaceProps;
enum SkColorType : int;
namespace skgpu {
@@ -93,7 +93,7 @@
@return SkSurface if all parameters are valid; otherwise, nullptr
*/
SK_API sk_sp<SkSurface> RenderTarget(GrRecordingContext* context,
- const SkSurfaceCharacterization& characterization,
+ const GrSurfaceCharacterization& characterization,
skgpu::Budgeted budgeted);
/** Wraps a GPU-backed texture into SkSurface. Caller must ensure the texture is
diff --git a/include/private/chromium/BUILD.bazel b/include/private/chromium/BUILD.bazel
index f45d9c1..4e79cc3 100644
--- a/include/private/chromium/BUILD.bazel
+++ b/include/private/chromium/BUILD.bazel
@@ -16,7 +16,10 @@
skia_filegroup(
name = "gpu_private_hdrs",
srcs = [
+ "GrDeferredDisplayList.h",
+ "GrDeferredDisplayListRecorder.h",
"GrSlug.h",
+ "GrSurfaceCharacterization.h",
],
)
@@ -43,6 +46,9 @@
":discardable_memory_hdrs",
":shared_private_hdrs",
] + select({
+ "//src/gpu:has_gpu_backend": [":gpu_private_hdrs"],
+ "//conditions:default": [],
+ }) + select({
"//src/gpu:vulkan_backend": [":vk_chromium_hdrs"],
"//conditions:default": [],
}),
diff --git a/include/private/chromium/GrDeferredDisplayList.h b/include/private/chromium/GrDeferredDisplayList.h
new file mode 100644
index 0000000..e54b51c
--- /dev/null
+++ b/include/private/chromium/GrDeferredDisplayList.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDeferredDisplayList_DEFINED
+#define GrDeferredDisplayList_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrRecordingContext.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
+
+class GrDirectContext;
+class GrRenderTargetProxy;
+class GrRenderTask;
+class GrDeferredDisplayListPriv;
+class SkSurface;
+
+/*
+ * This class contains pre-processed gpu operations that can be replayed into
+ * an SkSurface via SkSurface::draw(GrDeferredDisplayList*).
+ */
+class GrDeferredDisplayList : public SkNVRefCnt<GrDeferredDisplayList> {
+public:
+ SK_API ~GrDeferredDisplayList();
+
+ SK_API const GrSurfaceCharacterization& characterization() const {
+ return fCharacterization;
+ }
+ /**
+ * Iterate through the programs required by the DDL.
+ */
+ class SK_API ProgramIterator {
+ public:
+ ProgramIterator(GrDirectContext*, GrDeferredDisplayList*);
+ ~ProgramIterator();
+
+ // This returns true if any work was done. Getting a cache hit does not count as work.
+ bool compile();
+ bool done() const;
+ void next();
+
+ private:
+ GrDirectContext* fDContext;
+ const skia_private::TArray<GrRecordingContext::ProgramData>& fProgramData;
+ int fIndex;
+ };
+
+ // Provides access to functions that aren't part of the public API.
+ GrDeferredDisplayListPriv priv();
+ const GrDeferredDisplayListPriv priv() const; // NOLINT(readability-const-return-type)
+
+private:
+ friend class GrDrawingManager; // for access to 'fRenderTasks', 'fLazyProxyData', 'fArenas'
+ friend class GrDeferredDisplayListRecorder; // for access to 'fLazyProxyData'
+ friend class GrDeferredDisplayListPriv;
+
+ // This object is the source from which the lazy proxy backing the DDL will pull its backing
+ // texture when the DDL is replayed. It has to be separately ref counted bc the lazy proxy
+ // can outlive the DDL.
+ class LazyProxyData : public SkRefCnt {
+ public:
+ // Upon being replayed - this field will be filled in (by the DrawingManager) with the
+ // proxy backing the destination SkSurface. Note that, since there is no good place to
+ // clear it, it can become a dangling pointer. Additionally, since the renderTargetProxy
+ // doesn't get a ref here, the SkSurface that owns it must remain alive until the DDL
+ // is flushed.
+ // TODO: the drawing manager could ref the renderTargetProxy for the DDL and then add
+ // a renderingTask to unref it after the DDL's ops have been executed.
+ GrRenderTargetProxy* fReplayDest = nullptr;
+ };
+
+ SK_API GrDeferredDisplayList(const GrSurfaceCharacterization& characterization,
+ sk_sp<GrRenderTargetProxy> fTargetProxy,
+ sk_sp<LazyProxyData>);
+
+ const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
+ return fProgramData;
+ }
+
+ const GrSurfaceCharacterization fCharacterization;
+
+ // These are ordered such that the destructor cleans op tasks up first (which may refer back
+ // to the arena and memory pool in their destructors).
+ GrRecordingContext::OwnedArenas fArenas;
+ skia_private::TArray<sk_sp<GrRenderTask>> fRenderTasks;
+
+ skia_private::TArray<GrRecordingContext::ProgramData> fProgramData;
+ sk_sp<GrRenderTargetProxy> fTargetProxy;
+ sk_sp<LazyProxyData> fLazyProxyData;
+};
+
+namespace skgpu::ganesh {
+/** Draws the deferred display list created via a GrDeferredDisplayListRecorder.
+ If the deferred display list is not compatible with the surface, the draw is skipped
+ and false is return.
+
+ The xOffset and yOffset parameters are experimental and, if not both zero, will cause
+ the draw to be ignored.
+ When implemented, if xOffset or yOffset are non-zero, the DDL will be drawn offset by that
+ amount into the surface.
+
+ @param SkSurface The surface to apply the commands to, cannot be nullptr.
+ @param ddl drawing commands, cannot be nullptr.
+ @return false if ddl is not compatible
+
+ example: https://fiddle.skia.org/c/@Surface_draw_2
+*/
+SK_API bool DrawDDL(SkSurface*,
+ sk_sp<const GrDeferredDisplayList> ddl);
+
+SK_API bool DrawDDL(sk_sp<SkSurface>,
+ sk_sp<const GrDeferredDisplayList> ddl);
+}
+
+#endif
diff --git a/include/private/chromium/GrDeferredDisplayListRecorder.h b/include/private/chromium/GrDeferredDisplayListRecorder.h
new file mode 100644
index 0000000..ce653df
--- /dev/null
+++ b/include/private/chromium/GrDeferredDisplayListRecorder.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDeferredDisplayListRecorder_DEFINED
+#define GrDeferredDisplayListRecorder_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
+
+class GrBackendFormat;
+class GrRecordingContext;
+class GrRenderTargetProxy;
+class GrYUVABackendTextureInfo;
+class SkCanvas;
+class SkColorSpace;
+class SkImage;
+class SkPromiseImageTexture;
+class SkSurface;
+enum SkAlphaType : int;
+enum SkColorType : int;
+
+/*
+ * This class is intended to be used as:
+ * Get a GrSurfaceCharacterization representing the intended gpu-backed destination SkSurface
+ * Create one of these (a GrDeferredDisplayListRecorder) on the stack
+ * Get the canvas and render into it
+ * Snap off and hold on to a GrDeferredDisplayList
+ * Once your app actually needs the pixels, call skgpu::ganesh::DrawDDL(GrDeferredDisplayList*)
+ *
+ * This class never accesses the GPU but performs all the cpu work it can. It
+ * is thread-safe (i.e., one can break a scene into tiles and perform their cpu-side
+ * work in parallel ahead of time).
+ */
+class SK_API GrDeferredDisplayListRecorder {
+public:
+ GrDeferredDisplayListRecorder(const GrSurfaceCharacterization&);
+ ~GrDeferredDisplayListRecorder();
+
+ const GrSurfaceCharacterization& characterization() const {
+ return fCharacterization;
+ }
+
+ // The backing canvas will become invalid (and this entry point will return
+ // null) once 'detach' is called.
+ // Note: ownership of the SkCanvas is not transferred via this call.
+ SkCanvas* getCanvas();
+
+ sk_sp<GrDeferredDisplayList> detach();
+
+ using PromiseImageTextureContext = void*;
+ using PromiseImageTextureFulfillProc =
+ sk_sp<SkPromiseImageTexture> (*)(PromiseImageTextureContext);
+ using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
+
+#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
+ /** Deprecated: Use SkImages::PromiseTextureFrom instead. */
+ sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
+ int width,
+ int height,
+ GrMipmapped mipmapped,
+ GrSurfaceOrigin origin,
+ SkColorType colorType,
+ SkAlphaType alphaType,
+ sk_sp<SkColorSpace> colorSpace,
+ PromiseImageTextureFulfillProc textureFulfillProc,
+ PromiseImageTextureReleaseProc textureReleaseProc,
+ PromiseImageTextureContext textureContext);
+
+ /** Deprecated: Use SkImages::PromiseTextureFromYUVA instead. */
+ sk_sp<SkImage> makeYUVAPromiseTexture(const GrYUVABackendTextureInfo& yuvaBackendTextureInfo,
+ sk_sp<SkColorSpace> imageColorSpace,
+ PromiseImageTextureFulfillProc textureFulfillProc,
+ PromiseImageTextureReleaseProc textureReleaseProc,
+ PromiseImageTextureContext textureContexts[]);
+#endif // SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
+
+
+private:
+ GrDeferredDisplayListRecorder(const GrDeferredDisplayListRecorder&) = delete;
+ GrDeferredDisplayListRecorder& operator=(const GrDeferredDisplayListRecorder&) = delete;
+
+ bool init();
+
+ const GrSurfaceCharacterization fCharacterization;
+ sk_sp<GrRecordingContext> fContext;
+ sk_sp<GrRenderTargetProxy> fTargetProxy;
+ sk_sp<GrDeferredDisplayList::LazyProxyData> fLazyProxyData;
+ sk_sp<SkSurface> fSurface;
+};
+
+#endif
diff --git a/include/private/chromium/GrSurfaceCharacterization.h b/include/private/chromium/GrSurfaceCharacterization.h
new file mode 100644
index 0000000..4633f37
--- /dev/null
+++ b/include/private/chromium/GrSurfaceCharacterization.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrSurfaceCharacterization_DEFINED
+#define GrSurfaceCharacterization_DEFINED
+
+#include "include/core/SkColorSpace.h" // IWYU pragma: keep
+#include "include/core/SkColorType.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrContextThreadSafeProxy.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/base/SkDebug.h"
+
+#include <cstddef>
+#include <utility>
+
+/** \class GrSurfaceCharacterization
+ A surface characterization contains all the information Ganesh requires to makes its internal
+ rendering decisions. When passed into a GrDeferredDisplayListRecorder it will copy the
+ data and pass it on to the GrDeferredDisplayList if/when it is created. Note that both of
+ those objects (the Recorder and the DisplayList) will take a ref on the
+ GrContextThreadSafeProxy and SkColorSpace objects.
+*/
+class SK_API GrSurfaceCharacterization {
+public:
+ enum class Textureable : bool { kNo = false, kYes = true };
+ enum class MipMapped : bool { kNo = false, kYes = true };
+ enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
+ // This flag indicates that the backing VkImage for this Vulkan surface will have the
+ // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
+ // more optimally in a shader by being able to directly read the dst values.
+ enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true };
+ // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer.
+ enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true };
+
+ GrSurfaceCharacterization()
+ : fCacheMaxResourceBytes(0)
+ , fOrigin(kBottomLeft_GrSurfaceOrigin)
+ , fSampleCnt(0)
+ , fIsTextureable(Textureable::kYes)
+ , fIsMipMapped(MipMapped::kYes)
+ , fUsesGLFBO0(UsesGLFBO0::kNo)
+ , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
+ , fIsProtected(GrProtected::kNo)
+ , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
+ }
+
+ GrSurfaceCharacterization(GrSurfaceCharacterization&&) = default;
+ GrSurfaceCharacterization& operator=(GrSurfaceCharacterization&&) = default;
+
+ GrSurfaceCharacterization(const GrSurfaceCharacterization&) = default;
+ GrSurfaceCharacterization& operator=(const GrSurfaceCharacterization& other) = default;
+ bool operator==(const GrSurfaceCharacterization& other) const;
+ bool operator!=(const GrSurfaceCharacterization& other) const {
+ return !(*this == other);
+ }
+
+ /*
+ * Return a new surface characterization with the only difference being a different width
+ * and height
+ */
+ GrSurfaceCharacterization createResized(int width, int height) const;
+
+ /*
+ * Return a new surface characterization with only a replaced color space
+ */
+ GrSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const;
+
+ /*
+ * Return a new surface characterization with the backend format replaced. A colorType
+ * must also be supplied to indicate the interpretation of the new format.
+ */
+ GrSurfaceCharacterization createBackendFormat(SkColorType colorType,
+ const GrBackendFormat& backendFormat) const;
+
+ /*
+ * Return a new surface characterization with just a different use of FBO0 (in GL)
+ */
+ GrSurfaceCharacterization createFBO0(bool usesGLFBO0) const;
+
+ GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
+ sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; }
+ size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
+
+ bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); }
+
+ const SkImageInfo& imageInfo() const { return fImageInfo; }
+ const GrBackendFormat& backendFormat() const { return fBackendFormat; }
+ GrSurfaceOrigin origin() const { return fOrigin; }
+ SkISize dimensions() const { return fImageInfo.dimensions(); }
+ int width() const { return fImageInfo.width(); }
+ int height() const { return fImageInfo.height(); }
+ SkColorType colorType() const { return fImageInfo.colorType(); }
+ int sampleCount() const { return fSampleCnt; }
+ bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
+ bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
+ bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
+ bool vkRTSupportsInputAttachment() const {
+ return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
+ }
+ bool vulkanSecondaryCBCompatible() const {
+ return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
+ }
+ GrProtected isProtected() const { return fIsProtected; }
+ SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
+ sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
+ const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
+
+ // Is the provided backend texture compatible with this surface characterization?
+ bool isCompatible(const GrBackendTexture&) const;
+
+private:
+ friend class SkSurface_Ganesh; // for 'set' & 'config'
+ friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
+ friend class GrContextThreadSafeProxy; // for private ctor
+ friend class GrDeferredDisplayListRecorder; // for 'config'
+ friend class SkSurface; // for 'config'
+
+ SkDEBUGCODE(void validate() const;)
+
+ GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
+ size_t cacheMaxResourceBytes,
+ const SkImageInfo& ii,
+ const GrBackendFormat& backendFormat,
+ GrSurfaceOrigin origin,
+ int sampleCnt,
+ Textureable isTextureable,
+ MipMapped isMipMapped,
+ UsesGLFBO0 usesGLFBO0,
+ VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+ VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+ GrProtected isProtected,
+ const SkSurfaceProps& surfaceProps)
+ : fContextInfo(std::move(contextInfo))
+ , fCacheMaxResourceBytes(cacheMaxResourceBytes)
+ , fImageInfo(ii)
+ , fBackendFormat(backendFormat)
+ , fOrigin(origin)
+ , fSampleCnt(sampleCnt)
+ , fIsTextureable(isTextureable)
+ , fIsMipMapped(isMipMapped)
+ , fUsesGLFBO0(usesGLFBO0)
+ , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
+ , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
+ , fIsProtected(isProtected)
+ , fSurfaceProps(surfaceProps) {
+ if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+ // Dynamic MSAA is not currently supported with DDL.
+ *this = {};
+ }
+ SkDEBUGCODE(this->validate());
+ }
+
+ void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
+ size_t cacheMaxResourceBytes,
+ const SkImageInfo& ii,
+ const GrBackendFormat& backendFormat,
+ GrSurfaceOrigin origin,
+ int sampleCnt,
+ Textureable isTextureable,
+ MipMapped isMipMapped,
+ UsesGLFBO0 usesGLFBO0,
+ VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+ VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+ GrProtected isProtected,
+ const SkSurfaceProps& surfaceProps) {
+ if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+ // Dynamic MSAA is not currently supported with DDL.
+ *this = {};
+ } else {
+ fContextInfo = contextInfo;
+ fCacheMaxResourceBytes = cacheMaxResourceBytes;
+
+ fImageInfo = ii;
+ fBackendFormat = backendFormat;
+ fOrigin = origin;
+ fSampleCnt = sampleCnt;
+ fIsTextureable = isTextureable;
+ fIsMipMapped = isMipMapped;
+ fUsesGLFBO0 = usesGLFBO0;
+ fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
+ fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
+ fIsProtected = isProtected;
+ fSurfaceProps = surfaceProps;
+ }
+ SkDEBUGCODE(this->validate());
+ }
+
+ sk_sp<GrContextThreadSafeProxy> fContextInfo;
+ size_t fCacheMaxResourceBytes;
+
+ SkImageInfo fImageInfo;
+ GrBackendFormat fBackendFormat;
+ GrSurfaceOrigin fOrigin;
+ int fSampleCnt;
+ Textureable fIsTextureable;
+ MipMapped fIsMipMapped;
+ UsesGLFBO0 fUsesGLFBO0;
+ VkRTSupportsInputAttachment fVkRTSupportsInputAttachment;
+ VulkanSecondaryCBCompatible fVulkanSecondaryCBCompatible;
+ GrProtected fIsProtected;
+ SkSurfaceProps fSurfaceProps;
+};
+
+#endif
diff --git a/include/private/chromium/GrVkSecondaryCBDrawContext.h b/include/private/chromium/GrVkSecondaryCBDrawContext.h
index 51ed8a8..a40813d 100644
--- a/include/private/chromium/GrVkSecondaryCBDrawContext.h
+++ b/include/private/chromium/GrVkSecondaryCBDrawContext.h
@@ -15,15 +15,15 @@
#include <memory>
class GrBackendSemaphore;
+class GrDeferredDisplayList;
class GrRecordingContext;
+class GrSurfaceCharacterization;
struct GrVkDrawableInfo;
namespace skgpu::ganesh {
class Device;
}
class SkCanvas;
-class SkDeferredDisplayList;
struct SkImageInfo;
-class SkSurfaceCharacterization;
class SkSurfaceProps;
/**
@@ -107,15 +107,15 @@
const SkSurfaceProps& props() const { return fProps; }
// TODO: Fill out these calls to support DDL
- bool characterize(SkSurfaceCharacterization* characterization) const;
+ bool characterize(GrSurfaceCharacterization* characterization) const;
#ifndef SK_DDL_IS_UNIQUE_POINTER
- bool draw(sk_sp<const SkDeferredDisplayList> deferredDisplayList);
+ bool draw(sk_sp<const GrDeferredDisplayList> deferredDisplayList);
#else
- bool draw(const SkDeferredDisplayList* deferredDisplayList);
+ bool draw(const GrDeferredDisplayList* deferredDisplayList);
#endif
- bool isCompatible(const SkSurfaceCharacterization& characterization) const;
+ bool isCompatible(const GrSurfaceCharacterization& characterization) const;
private:
explicit GrVkSecondaryCBDrawContext(sk_sp<skgpu::ganesh::Device>, const SkSurfaceProps*);
diff --git a/include/private/gpu/ganesh/GrContext_Base.h b/include/private/gpu/ganesh/GrContext_Base.h
index c3f4ca3..450bea4 100644
--- a/include/private/gpu/ganesh/GrContext_Base.h
+++ b/include/private/gpu/ganesh/GrContext_Base.h
@@ -42,7 +42,7 @@
/*
* Retrieve the default GrBackendFormat for a given SkColorType and renderability.
* It is guaranteed that this backend format will be the one used by the GrContext
- * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+ * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
*
* The caller should check that the returned format is valid.
*/
diff --git a/include/private/gpu/ganesh/GrTypesPriv.h b/include/private/gpu/ganesh/GrTypesPriv.h
index 84e2346..122867b 100644
--- a/include/private/gpu/ganesh/GrTypesPriv.h
+++ b/include/private/gpu/ganesh/GrTypesPriv.h
@@ -465,7 +465,7 @@
// require that both the surface and proxy have matching values for this flag. Instead we require
// if the proxy has it set then the surface must also have it set. All other flags listed here must
// match on the proxy and surface.
-// TODO: Add back kFramebufferOnly flag here once we update SkSurfaceCharacterization to take it
+// TODO: Add back kFramebufferOnly flag here once we update GrSurfaceCharacterization to take it
// as a flag. skbug.com/10672
constexpr static int kGrInternalRenderTargetFlagsMask = static_cast<int>(
GrInternalSurfaceFlags::kGLRTFBOIDIs0 |
diff --git a/public.bzl b/public.bzl
index 89488c2..11bffe4 100644
--- a/public.bzl
+++ b/public.bzl
@@ -44,8 +44,6 @@
"include/core/SkCubicMap.h",
"include/core/SkData.h",
"include/core/SkDataTable.h",
- "include/core/SkDeferredDisplayList.h",
- "include/core/SkDeferredDisplayListRecorder.h",
"include/core/SkDocument.h",
"include/core/SkDrawLooper.h",
"include/core/SkDrawable.h",
@@ -101,7 +99,6 @@
"include/core/SkString.h",
"include/core/SkStrokeRec.h",
"include/core/SkSurface.h",
- "include/core/SkSurfaceCharacterization.h",
"include/core/SkSurfaceProps.h",
"include/core/SkSwizzle.h",
"include/core/SkTextBlob.h",
@@ -282,6 +279,9 @@
"include/private/base/SkThreadID.h",
"include/private/base/SkTo.h",
"include/private/base/SkTypeTraits.h",
+ "include/private/chromium/GrDeferredDisplayList.h",
+ "include/private/chromium/GrDeferredDisplayListRecorder.h",
+ "include/private/chromium/GrSurfaceCharacterization.h",
"include/private/chromium/SkChromeRemoteGlyphCache.h",
"include/private/chromium/SkDiscardableMemory.h",
"include/private/chromium/Slug.h",
@@ -431,9 +431,6 @@
"src/core/SkDataTable.cpp",
"src/core/SkDebug.cpp",
"src/core/SkDebugUtils.h",
- "src/core/SkDeferredDisplayList.cpp",
- "src/core/SkDeferredDisplayListPriv.h",
- "src/core/SkDeferredDisplayListRecorder.cpp",
"src/core/SkDescriptor.cpp",
"src/core/SkDescriptor.h",
"src/core/SkDevice.cpp",
@@ -665,7 +662,6 @@
"src/core/SkStrokeRec.cpp",
"src/core/SkStrokerPriv.cpp",
"src/core/SkStrokerPriv.h",
- "src/core/SkSurfaceCharacterization.cpp",
"src/core/SkSurfacePriv.h",
"src/core/SkSwizzle.cpp",
"src/core/SkSwizzlePriv.h",
@@ -861,6 +857,9 @@
"src/gpu/ganesh/GrDataUtils.h",
"src/gpu/ganesh/GrDefaultGeoProcFactory.cpp",
"src/gpu/ganesh/GrDefaultGeoProcFactory.h",
+ "src/gpu/ganesh/GrDeferredDisplayList.cpp",
+ "src/gpu/ganesh/GrDeferredDisplayListPriv.h",
+ "src/gpu/ganesh/GrDeferredDisplayListRecorder.cpp",
"src/gpu/ganesh/GrDeferredProxyUploader.h",
"src/gpu/ganesh/GrDeferredUpload.h",
"src/gpu/ganesh/GrDirectContext.cpp",
@@ -986,6 +985,7 @@
"src/gpu/ganesh/GrStyle.h",
"src/gpu/ganesh/GrSurface.cpp",
"src/gpu/ganesh/GrSurface.h",
+ "src/gpu/ganesh/GrSurfaceCharacterization.cpp",
"src/gpu/ganesh/GrSurfaceInfo.cpp",
"src/gpu/ganesh/GrSurfaceProxy.cpp",
"src/gpu/ganesh/GrSurfaceProxy.h",
diff --git a/relnotes/ddl_private.md b/relnotes/ddl_private.md
new file mode 100644
index 0000000..f14d4fe
--- /dev/null
+++ b/relnotes/ddl_private.md
@@ -0,0 +1,2 @@
+`SkDeferredDisplayList`, `SkDeferredDisplayListRecorder`, and `SkSurfaceCharacterization` have
+been removed from the public API.
\ No newline at end of file
diff --git a/src/core/BUILD.bazel b/src/core/BUILD.bazel
index 7ff541f..6c03335 100644
--- a/src/core/BUILD.bazel
+++ b/src/core/BUILD.bazel
@@ -102,9 +102,6 @@
"SkDataTable.cpp",
"SkDebug.cpp",
"SkDebugUtils.h",
- "SkDeferredDisplayList.cpp",
- "SkDeferredDisplayListPriv.h",
- "SkDeferredDisplayListRecorder.cpp",
"SkDescriptor.cpp",
"SkDescriptor.h",
"SkDevice.cpp",
@@ -307,7 +304,6 @@
"SkStrokeRec.cpp",
"SkStrokerPriv.cpp",
"SkStrokerPriv.h",
- "SkSurfaceCharacterization.cpp",
"SkSurfacePriv.h",
"SkSwizzle.cpp",
"SkSwizzlePriv.h",
diff --git a/src/core/SkDeferredDisplayList.cpp b/src/core/SkDeferredDisplayList.cpp
deleted file mode 100644
index 9c9e98c..0000000
--- a/src/core/SkDeferredDisplayList.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "include/core/SkDeferredDisplayList.h"
-
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkTypes.h"
-#include "src/base/SkArenaAlloc.h"
-
-#include <utility>
-
-class SkSurfaceCharacterization;
-
-#if defined(SK_GANESH)
-#include "src/gpu/ganesh/GrDirectContextPriv.h"
-#include "src/gpu/ganesh/GrRenderTargetProxy.h"
-#include "src/gpu/ganesh/GrRenderTask.h"
-#endif
-
-SkDeferredDisplayList::SkDeferredDisplayList(const SkSurfaceCharacterization& characterization,
- sk_sp<GrRenderTargetProxy> targetProxy,
- sk_sp<LazyProxyData> lazyProxyData)
- : fCharacterization(characterization)
-#if defined(SK_GANESH)
- , fArenas(true)
- , fTargetProxy(std::move(targetProxy))
- , fLazyProxyData(std::move(lazyProxyData))
-#endif
-{
-#if defined(SK_GANESH)
- SkASSERT(fTargetProxy->isDDLTarget());
-#endif
-}
-
-SkDeferredDisplayList::~SkDeferredDisplayList() {
-#if defined(SK_GANESH) && defined(SK_DEBUG)
- for (auto& renderTask : fRenderTasks) {
- SkASSERT(renderTask->unique());
- }
-#endif
-}
-
-//-------------------------------------------------------------------------------------------------
-#if defined(SK_GANESH)
-
-SkDeferredDisplayList::ProgramIterator::ProgramIterator(GrDirectContext* dContext,
- SkDeferredDisplayList* ddl)
- : fDContext(dContext)
- , fProgramData(ddl->programData())
- , fIndex(0) {
-}
-
-SkDeferredDisplayList::ProgramIterator::~ProgramIterator() {}
-
-bool SkDeferredDisplayList::ProgramIterator::compile() {
- if (!fDContext || fIndex < 0 || fIndex >= (int) fProgramData.size()) {
- return false;
- }
-
- return fDContext->priv().compile(fProgramData[fIndex].desc(), fProgramData[fIndex].info());
-}
-
-bool SkDeferredDisplayList::ProgramIterator::done() const {
- return fIndex >= (int) fProgramData.size();
-}
-
-void SkDeferredDisplayList::ProgramIterator::next() {
- ++fIndex;
-}
-
-#endif
diff --git a/src/core/SkDeferredDisplayListPriv.h b/src/core/SkDeferredDisplayListPriv.h
deleted file mode 100644
index d6321cb..0000000
--- a/src/core/SkDeferredDisplayListPriv.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkDeferredDisplayListPriv_DEFINED
-#define SkDeferredDisplayListPriv_DEFINED
-
-#include "include/core/SkDeferredDisplayList.h"
-
-/*************************************************************************************************/
-/** Class that adds methods to SkDeferredDisplayList that are only intended for use internal to Skia.
- This class is purely a privileged window into SkDeferredDisplayList. It should never have
- additional data members or virtual methods. */
-class SkDeferredDisplayListPriv {
-public:
-
-#if defined(SK_GANESH)
- int numRenderTasks() const {
- return fDDL->fRenderTasks.size();
- }
-
- GrRenderTargetProxy* targetProxy() const {
- return fDDL->fTargetProxy.get();
- }
-
- const SkDeferredDisplayList::LazyProxyData* lazyProxyData() const {
- return fDDL->fLazyProxyData.get();
- }
-
- const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
- return fDDL->programData();
- }
-
- const skia_private::TArray<sk_sp<GrRenderTask>>& renderTasks() const {
- return fDDL->fRenderTasks;
- }
-#endif
-
-private:
- explicit SkDeferredDisplayListPriv(SkDeferredDisplayList* ddl) : fDDL(ddl) {}
- SkDeferredDisplayListPriv& operator=(const SkDeferredDisplayListPriv&) = delete;
-
- // No taking addresses of this type.
- const SkDeferredDisplayListPriv* operator&() const;
- SkDeferredDisplayListPriv* operator&();
-
- SkDeferredDisplayList* fDDL;
-
- friend class SkDeferredDisplayList; // to construct/copy this type.
-};
-
-inline SkDeferredDisplayListPriv SkDeferredDisplayList::priv() {
- return SkDeferredDisplayListPriv(this);
-}
-
-inline const SkDeferredDisplayListPriv SkDeferredDisplayList::priv () const { // NOLINT(readability-const-return-type)
- return SkDeferredDisplayListPriv(const_cast<SkDeferredDisplayList*>(this));
-}
-
-#endif
diff --git a/src/gpu/ganesh/BUILD.bazel b/src/gpu/ganesh/BUILD.bazel
index 023c213..86f2879 100644
--- a/src/gpu/ganesh/BUILD.bazel
+++ b/src/gpu/ganesh/BUILD.bazel
@@ -74,6 +74,9 @@
"GrDefaultGeoProcFactory.h",
"GrDeferredProxyUploader.h",
"GrDeferredUpload.h",
+ "GrDeferredDisplayList.cpp",
+ "GrDeferredDisplayListPriv.h",
+ "GrDeferredDisplayListRecorder.cpp",
"GrDirectContext.cpp",
"GrDirectContextPriv.cpp",
"GrDirectContextPriv.h",
@@ -194,15 +197,16 @@
"GrStyle.h",
"GrSurface.cpp",
"GrSurface.h",
+ "GrSurfaceCharacterization.cpp",
"GrSurfaceInfo.cpp",
"GrSurfaceProxy.cpp",
"GrSurfaceProxy.h",
"GrSurfaceProxyPriv.h",
"GrSurfaceProxyView.cpp",
"GrSurfaceProxyView.h",
- "GrTTopoSort.h",
"GrTestUtils.cpp",
"GrTestUtils.h",
+ "GrTTopoSort.h",
"GrTexture.cpp",
"GrTexture.h",
"GrTextureProxy.cpp",
diff --git a/src/gpu/ganesh/GrContextThreadSafeProxy.cpp b/src/gpu/ganesh/GrContextThreadSafeProxy.cpp
index e65d9ee..2ed0bf6 100644
--- a/src/gpu/ganesh/GrContextThreadSafeProxy.cpp
+++ b/src/gpu/ganesh/GrContextThreadSafeProxy.cpp
@@ -5,15 +5,13 @@
* found in the LICENSE file.
*/
-#include <memory>
-
#include "include/gpu/GrContextThreadSafeProxy.h"
-#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkTextureCompressionType.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "src/gpu/ganesh/GrBaseContextPriv.h"
#include "src/gpu/ganesh/GrCaps.h"
+#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrThreadSafeCache.h"
#include "src/gpu/ganesh/GrThreadSafePipelineBuilder.h"
#include "src/gpu/ganesh/effects/GrSkSLFP.h"
@@ -23,6 +21,8 @@
#include "src/gpu/ganesh/vk/GrVkCaps.h"
#endif
+#include <memory>
+
static int32_t next_id() {
static std::atomic<int32_t> nextID{1};
int32_t id;
@@ -48,7 +48,7 @@
fPipelineBuilder = std::move(pipelineBuilder);
}
-SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
+GrSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
size_t cacheMaxResourceBytes,
const SkImageInfo& ii, const GrBackendFormat& backendFormat,
int sampleCnt, GrSurfaceOrigin origin,
@@ -126,15 +126,15 @@
#endif
}
- return SkSurfaceCharacterization(
+ return GrSurfaceCharacterization(
sk_ref_sp<GrContextThreadSafeProxy>(this),
cacheMaxResourceBytes, ii, backendFormat,
origin, sampleCnt,
- SkSurfaceCharacterization::Textureable(isTextureable),
- SkSurfaceCharacterization::MipMapped(isMipMapped),
- SkSurfaceCharacterization::UsesGLFBO0(willUseGLFBO0),
- SkSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
- SkSurfaceCharacterization::VulkanSecondaryCBCompatible(forVulkanSecondaryCommandBuffer),
+ GrSurfaceCharacterization::Textureable(isTextureable),
+ GrSurfaceCharacterization::MipMapped(isMipMapped),
+ GrSurfaceCharacterization::UsesGLFBO0(willUseGLFBO0),
+ GrSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
+ GrSurfaceCharacterization::VulkanSecondaryCBCompatible(forVulkanSecondaryCommandBuffer),
isProtected,
surfaceProps);
}
diff --git a/src/gpu/ganesh/GrDDLTask.cpp b/src/gpu/ganesh/GrDDLTask.cpp
index e8da7a9..b1f607e 100644
--- a/src/gpu/ganesh/GrDDLTask.cpp
+++ b/src/gpu/ganesh/GrDDLTask.cpp
@@ -7,19 +7,16 @@
#include "src/gpu/ganesh/GrDDLTask.h"
-#include "include/core/SkDeferredDisplayList.h"
-#include "src/core/SkDeferredDisplayListPriv.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "src/gpu/ganesh/GrDeferredDisplayListPriv.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrResourceAllocator.h"
GrDDLTask::GrDDLTask(GrDrawingManager* drawingMgr,
sk_sp<GrRenderTargetProxy> ddlTarget,
- sk_sp<const SkDeferredDisplayList> ddl,
- SkIPoint offset)
+ sk_sp<const GrDeferredDisplayList> ddl)
: fDDL(std::move(ddl))
- , fDDLTarget(std::move(ddlTarget))
- , fOffset(offset) {
- (void) fOffset; // fOffset will be used shortly
+ , fDDLTarget(std::move(ddlTarget)) {
for (auto& task : fDDL->priv().renderTasks()) {
SkASSERT(task->isClosed());
diff --git a/src/gpu/ganesh/GrDDLTask.h b/src/gpu/ganesh/GrDDLTask.h
index b14d6b6..1cc5813 100644
--- a/src/gpu/ganesh/GrDDLTask.h
+++ b/src/gpu/ganesh/GrDDLTask.h
@@ -11,6 +11,7 @@
#include "include/core/SkPoint.h"
#include "src/gpu/ganesh/GrRenderTask.h"
+class GrDeferredDisplayList;
class GrRenderTargetProxy;
/**
@@ -23,8 +24,7 @@
public:
GrDDLTask(GrDrawingManager*,
sk_sp<GrRenderTargetProxy> ddlTarget,
- sk_sp<const SkDeferredDisplayList>,
- SkIPoint offset);
+ sk_sp<const GrDeferredDisplayList>);
~GrDDLTask() override;
@@ -65,9 +65,8 @@
void visitProxies_debugOnly(const GrVisitProxyFunc&) const override {}
#endif
- sk_sp<const SkDeferredDisplayList> fDDL;
+ sk_sp<const GrDeferredDisplayList> fDDL;
sk_sp<GrRenderTargetProxy> fDDLTarget;
- SkIPoint fOffset;
typedef GrRenderTask INHERITED;
};
diff --git a/src/gpu/ganesh/GrDeferredDisplayList.cpp b/src/gpu/ganesh/GrDeferredDisplayList.cpp
new file mode 100644
index 0000000..01311eb
--- /dev/null
+++ b/src/gpu/ganesh/GrDeferredDisplayList.cpp
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "include/private/chromium/GrDeferredDisplayList.h"
+
+#include "include/gpu/GrDirectContext.h"
+#include "src/gpu/ganesh/GrDirectContextPriv.h"
+#include "src/gpu/ganesh/GrRenderTargetProxy.h"
+#include "src/gpu/ganesh/GrRenderTask.h"
+#include "src/gpu/ganesh/surface/SkSurface_Ganesh.h"
+#include "src/image/SkSurface_Base.h"
+
+#include <utility>
+
+GrDeferredDisplayList::GrDeferredDisplayList(const GrSurfaceCharacterization& characterization,
+ sk_sp<GrRenderTargetProxy> targetProxy,
+ sk_sp<LazyProxyData> lazyProxyData)
+ : fCharacterization(characterization)
+ , fArenas(true)
+ , fTargetProxy(std::move(targetProxy))
+ , fLazyProxyData(std::move(lazyProxyData)) {
+ SkASSERT(fTargetProxy->isDDLTarget());
+}
+
+GrDeferredDisplayList::~GrDeferredDisplayList() {
+#if defined(SK_DEBUG)
+ for (auto& renderTask : fRenderTasks) {
+ SkASSERT(renderTask->unique());
+ }
+#endif
+}
+
+GrDeferredDisplayList::ProgramIterator::ProgramIterator(GrDirectContext* dContext,
+ GrDeferredDisplayList* ddl)
+ : fDContext(dContext)
+ , fProgramData(ddl->programData())
+ , fIndex(0) {
+}
+
+GrDeferredDisplayList::ProgramIterator::~ProgramIterator() {}
+
+bool GrDeferredDisplayList::ProgramIterator::compile() {
+ if (!fDContext || fIndex < 0 || fIndex >= (int) fProgramData.size()) {
+ return false;
+ }
+
+ return fDContext->priv().compile(fProgramData[fIndex].desc(), fProgramData[fIndex].info());
+}
+
+bool GrDeferredDisplayList::ProgramIterator::done() const {
+ return fIndex >= (int) fProgramData.size();
+}
+
+void GrDeferredDisplayList::ProgramIterator::next() {
+ ++fIndex;
+}
+
+namespace skgpu::ganesh {
+
+bool DrawDDL(SkSurface* surface, sk_sp<const GrDeferredDisplayList> ddl) {
+ if (!surface || !ddl) {
+ return false;
+ }
+ auto sb = asSB(surface);
+ if (!sb->isGaneshBacked()) {
+ return false;
+ }
+ auto gs = static_cast<SkSurface_Ganesh*>(surface);
+ return gs->draw(ddl);
+}
+
+bool DrawDDL(sk_sp<SkSurface> surface, sk_sp<const GrDeferredDisplayList> ddl) {
+ return DrawDDL(surface.get(), ddl);
+}
+
+}
diff --git a/src/gpu/ganesh/GrDeferredDisplayListPriv.h b/src/gpu/ganesh/GrDeferredDisplayListPriv.h
new file mode 100644
index 0000000..215a704
--- /dev/null
+++ b/src/gpu/ganesh/GrDeferredDisplayListPriv.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDeferredDisplayListPriv_DEFINED
+#define GrDeferredDisplayListPriv_DEFINED
+
+#include "include/private/chromium/GrDeferredDisplayList.h"
+
+/*************************************************************************************************/
+/** Class that adds methods to GrDeferredDisplayList that are only intended for use internal to
+ Skia. This class is purely a privileged window into GrDeferredDisplayList. It should never have
+ additional data members or virtual methods. */
+class GrDeferredDisplayListPriv {
+public:
+ int numRenderTasks() const {
+ return fDDL->fRenderTasks.size();
+ }
+
+ GrRenderTargetProxy* targetProxy() const {
+ return fDDL->fTargetProxy.get();
+ }
+
+ const GrDeferredDisplayList::LazyProxyData* lazyProxyData() const {
+ return fDDL->fLazyProxyData.get();
+ }
+
+ const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
+ return fDDL->programData();
+ }
+
+ const skia_private::TArray<sk_sp<GrRenderTask>>& renderTasks() const {
+ return fDDL->fRenderTasks;
+ }
+
+private:
+ explicit GrDeferredDisplayListPriv(GrDeferredDisplayList* ddl) : fDDL(ddl) {}
+ GrDeferredDisplayListPriv& operator=(const GrDeferredDisplayListPriv&) = delete;
+
+ // No taking addresses of this type.
+ const GrDeferredDisplayListPriv* operator&() const;
+ GrDeferredDisplayListPriv* operator&();
+
+ GrDeferredDisplayList* fDDL;
+
+ friend class GrDeferredDisplayList; // to construct/copy this type.
+};
+
+inline GrDeferredDisplayListPriv GrDeferredDisplayList::priv() {
+ return GrDeferredDisplayListPriv(this);
+}
+
+inline const GrDeferredDisplayListPriv GrDeferredDisplayList::priv () const { // NOLINT(readability-const-return-type)
+ return GrDeferredDisplayListPriv(const_cast<GrDeferredDisplayList*>(this));
+}
+
+#endif
diff --git a/src/core/SkDeferredDisplayListRecorder.cpp b/src/gpu/ganesh/GrDeferredDisplayListRecorder.cpp
similarity index 84%
rename from src/core/SkDeferredDisplayListRecorder.cpp
rename to src/gpu/ganesh/GrDeferredDisplayListRecorder.cpp
index 32ebc19..c9dcc53 100644
--- a/src/core/SkDeferredDisplayListRecorder.cpp
+++ b/src/gpu/ganesh/GrDeferredDisplayListRecorder.cpp
@@ -1,53 +1,47 @@
/*
- * Copyright 2017 Google Inc.
+ * Copyright 2023 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
-#include "include/core/SkDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
-#include "include/core/SkDeferredDisplayList.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkImage.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
-#include "src/core/SkMessageBus.h"
-
-#if !defined(SK_GANESH)
-SkDeferredDisplayListRecorder::SkDeferredDisplayListRecorder(const SkSurfaceCharacterization&) {}
-
-SkDeferredDisplayListRecorder::~SkDeferredDisplayListRecorder() {}
-
-bool SkDeferredDisplayListRecorder::init() { return false; }
-
-SkCanvas* SkDeferredDisplayListRecorder::getCanvas() { return nullptr; }
-
-sk_sp<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() { return nullptr; }
-
-#else
-
-#include "include/core/SkPromiseImageTexture.h"
+#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrRecordingContext.h"
-#include "include/gpu/GrYUVABackendTextures.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/SkBackingFit.h"
+#include "src/gpu/ganesh/Device.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
-#include "src/gpu/ganesh/GrTexture.h"
-#include "src/gpu/ganesh/SkGr.h"
-#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
-#include "src/gpu/ganesh/image/SkImage_GaneshYUVA.h"
+#include "src/gpu/ganesh/GrSurface.h"
+#include "src/gpu/ganesh/GrSurfaceProxy.h"
+#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include "src/gpu/ganesh/surface/SkSurface_Ganesh.h"
-SkDeferredDisplayListRecorder::SkDeferredDisplayListRecorder(const SkSurfaceCharacterization& c)
+#include <functional>
+#include <utility>
+
+class GrResourceProvider;
+
+GrDeferredDisplayListRecorder::GrDeferredDisplayListRecorder(const GrSurfaceCharacterization& c)
: fCharacterization(c) {
if (fCharacterization.isValid()) {
fContext = GrRecordingContextPriv::MakeDDL(fCharacterization.refContextInfo());
}
}
-SkDeferredDisplayListRecorder::~SkDeferredDisplayListRecorder() {
+GrDeferredDisplayListRecorder::~GrDeferredDisplayListRecorder() {
if (fContext) {
auto proxyProvider = fContext->priv().proxyProvider();
@@ -64,7 +58,7 @@
}
}
-bool SkDeferredDisplayListRecorder::init() {
+bool GrDeferredDisplayListRecorder::init() {
SkASSERT(fContext);
SkASSERT(!fTargetProxy);
SkASSERT(!fLazyProxyData);
@@ -74,8 +68,8 @@
return false;
}
- fLazyProxyData = sk_sp<SkDeferredDisplayList::LazyProxyData>(
- new SkDeferredDisplayList::LazyProxyData);
+ fLazyProxyData = sk_sp<GrDeferredDisplayList::LazyProxyData>(
+ new GrDeferredDisplayList::LazyProxyData);
auto proxyProvider = fContext->priv().proxyProvider();
const GrCaps* caps = fContext->priv().caps();
@@ -127,7 +121,7 @@
surfaceFlags |= GrInternalSurfaceFlags::kVkRTSupportsInputAttachment;
}
- // FIXME: Why do we use GrMipmapped::kNo instead of SkSurfaceCharacterization::fIsMipMapped?
+ // FIXME: Why do we use GrMipmapped::kNo instead of GrSurfaceCharacterization::fIsMipMapped?
static constexpr GrProxyProvider::TextureInfo kTextureInfo{GrMipmapped::kNo,
GrTextureType::k2D};
const GrProxyProvider::TextureInfo* optionalTextureInfo = nullptr;
@@ -176,7 +170,7 @@
return SkToBool(fSurface.get());
}
-SkCanvas* SkDeferredDisplayListRecorder::getCanvas() {
+SkCanvas* GrDeferredDisplayListRecorder::getCanvas() {
if (!fContext) {
return nullptr;
}
@@ -188,7 +182,7 @@
return fSurface->getCanvas();
}
-sk_sp<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() {
+sk_sp<GrDeferredDisplayList> GrDeferredDisplayListRecorder::detach() {
if (!fContext || !fTargetProxy) {
return nullptr;
}
@@ -199,7 +193,7 @@
canvas->restoreToCount(0);
}
- auto ddl = sk_sp<SkDeferredDisplayList>(new SkDeferredDisplayList(fCharacterization,
+ auto ddl = sk_sp<GrDeferredDisplayList>(new GrDeferredDisplayList(fCharacterization,
std::move(fTargetProxy),
std::move(fLazyProxyData)));
@@ -212,7 +206,7 @@
}
#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-sk_sp<SkImage> SkDeferredDisplayListRecorder::makePromiseTexture(
+sk_sp<SkImage> GrDeferredDisplayListRecorder::makePromiseTexture(
const GrBackendFormat& backendFormat,
int width,
int height,
@@ -240,7 +234,7 @@
textureContext);
}
-sk_sp<SkImage> SkDeferredDisplayListRecorder::makeYUVAPromiseTexture(
+sk_sp<SkImage> GrDeferredDisplayListRecorder::makeYUVAPromiseTexture(
const GrYUVABackendTextureInfo& backendTextureInfo,
sk_sp<SkColorSpace> imageColorSpace,
PromiseImageTextureFulfillProc textureFulfillProc,
@@ -257,5 +251,3 @@
textureContexts);
}
#endif // !SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-
-#endif
diff --git a/src/gpu/ganesh/GrDirectContextPriv.cpp b/src/gpu/ganesh/GrDirectContextPriv.cpp
index 75a7b58..44ca8e8 100644
--- a/src/gpu/ganesh/GrDirectContextPriv.cpp
+++ b/src/gpu/ganesh/GrDirectContextPriv.cpp
@@ -9,10 +9,10 @@
#include "include/core/SkBitmap.h"
#include "include/core/SkColorSpace.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrContextThreadSafeProxy.h"
#include "include/gpu/GrDirectContext.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrDrawingManager.h"
@@ -67,10 +67,9 @@
return this->context()->drawingManager()->flushSurfaces(proxies, access, info, newState);
}
-void GrDirectContextPriv::createDDLTask(sk_sp<const SkDeferredDisplayList> ddl,
- sk_sp<GrRenderTargetProxy> newDest,
- SkIPoint offset) {
- this->context()->drawingManager()->createDDLTask(std::move(ddl), std::move(newDest), offset);
+void GrDirectContextPriv::createDDLTask(sk_sp<const GrDeferredDisplayList> ddl,
+ sk_sp<GrRenderTargetProxy> newDest) {
+ this->context()->drawingManager()->createDDLTask(std::move(ddl), std::move(newDest));
}
bool GrDirectContextPriv::compile(const GrProgramDesc& desc, const GrProgramInfo& info) {
diff --git a/src/gpu/ganesh/GrDirectContextPriv.h b/src/gpu/ganesh/GrDirectContextPriv.h
index cf449e9..2bb62fe 100644
--- a/src/gpu/ganesh/GrDirectContextPriv.h
+++ b/src/gpu/ganesh/GrDirectContextPriv.h
@@ -25,7 +25,7 @@
class GrSemaphore;
class GrSurfaceProxy;
-class SkDeferredDisplayList;
+class GrDeferredDisplayList;
class SkTaskGroup;
/** Class that adds methods to GrDirectContext that are only intended for use internal to Skia.
@@ -100,9 +100,8 @@
}
#endif
- void createDDLTask(sk_sp<const SkDeferredDisplayList>,
- sk_sp<GrRenderTargetProxy> newDest,
- SkIPoint offset);
+ void createDDLTask(sk_sp<const GrDeferredDisplayList>,
+ sk_sp<GrRenderTargetProxy> newDest);
bool compile(const GrProgramDesc&, const GrProgramInfo&);
diff --git a/src/gpu/ganesh/GrDrawingManager.cpp b/src/gpu/ganesh/GrDrawingManager.cpp
index bea464b..a9f567d 100644
--- a/src/gpu/ganesh/GrDrawingManager.cpp
+++ b/src/gpu/ganesh/GrDrawingManager.cpp
@@ -10,17 +10,17 @@
#include <algorithm>
#include <memory>
-#include "include/core/SkDeferredDisplayList.h"
#include "include/gpu/GrBackendSemaphore.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
#include "src/base/SkTInternalLList.h"
-#include "src/core/SkDeferredDisplayListPriv.h"
#include "src/gpu/ganesh/GrBufferTransferRenderTask.h"
#include "src/gpu/ganesh/GrBufferUpdateRenderTask.h"
#include "src/gpu/ganesh/GrClientMappedBufferManager.h"
#include "src/gpu/ganesh/GrCopyRenderTask.h"
#include "src/gpu/ganesh/GrDDLTask.h"
+#include "src/gpu/ganesh/GrDeferredDisplayListPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrMemoryPool.h"
@@ -568,7 +568,7 @@
return task ? task->asOpsTask() : nullptr;
}
-void GrDrawingManager::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
+void GrDrawingManager::moveRenderTasksToDDL(GrDeferredDisplayList* ddl) {
SkDEBUGCODE(this->validate());
// no renderTask should receive a new command after this
@@ -593,9 +593,8 @@
SkDEBUGCODE(this->validate());
}
-void GrDrawingManager::createDDLTask(sk_sp<const SkDeferredDisplayList> ddl,
- sk_sp<GrRenderTargetProxy> newDest,
- SkIPoint offset) {
+void GrDrawingManager::createDDLTask(sk_sp<const GrDeferredDisplayList> ddl,
+ sk_sp<GrRenderTargetProxy> newDest) {
SkDEBUGCODE(this->validate());
if (fActiveOpsTask) {
@@ -627,8 +626,7 @@
// Add a task to handle drawing and lifetime management of the DDL.
SkDEBUGCODE(auto ddlTask =) this->appendTask(sk_make_sp<GrDDLTask>(this,
std::move(newDest),
- std::move(ddl),
- offset));
+ std::move(ddl)));
SkASSERT(ddlTask->isClosed());
SkDEBUGCODE(this->validate());
diff --git a/src/gpu/ganesh/GrDrawingManager.h b/src/gpu/ganesh/GrDrawingManager.h
index 2e83a49..6e53131 100644
--- a/src/gpu/ganesh/GrDrawingManager.h
+++ b/src/gpu/ganesh/GrDrawingManager.h
@@ -25,6 +25,7 @@
#define GR_PATH_RENDERER_SPEW 0
class GrArenas;
+class GrDeferredDisplayList;
class GrGpuBuffer;
class GrOnFlushCallbackObject;
class GrOpFlushState;
@@ -35,7 +36,6 @@
class GrSemaphore;
class GrSurfaceProxyView;
class GrTextureResolveRenderTask;
-class SkDeferredDisplayList;
namespace skgpu {
namespace ganesh {
class OpsTask;
@@ -174,10 +174,9 @@
skgpu::ganesh::OpsTask* getLastOpsTask(const GrSurfaceProxy*) const;
void setLastRenderTask(const GrSurfaceProxy*, GrRenderTask*);
- void moveRenderTasksToDDL(SkDeferredDisplayList* ddl);
- void createDDLTask(sk_sp<const SkDeferredDisplayList>,
- sk_sp<GrRenderTargetProxy> newDest,
- SkIPoint offset);
+ void moveRenderTasksToDDL(GrDeferredDisplayList* ddl);
+ void createDDLTask(sk_sp<const GrDeferredDisplayList>,
+ sk_sp<GrRenderTargetProxy> newDest);
// This is public so it can be called by an SkImage factory (in SkImages namespace).
// It is not meant to be directly called in other situations.
diff --git a/src/gpu/ganesh/GrRecordingContextPriv.cpp b/src/gpu/ganesh/GrRecordingContextPriv.cpp
index d4221bc..0bd4019 100644
--- a/src/gpu/ganesh/GrRecordingContextPriv.cpp
+++ b/src/gpu/ganesh/GrRecordingContextPriv.cpp
@@ -59,7 +59,7 @@
init);
}
-void GrRecordingContextPriv::moveRenderTasksToDDL(SkDeferredDisplayList* ddl) {
+void GrRecordingContextPriv::moveRenderTasksToDDL(GrDeferredDisplayList* ddl) {
this->context()->drawingManager()->moveRenderTasksToDDL(ddl);
}
diff --git a/src/gpu/ganesh/GrRecordingContextPriv.h b/src/gpu/ganesh/GrRecordingContextPriv.h
index 3bae1c8..db6733c 100644
--- a/src/gpu/ganesh/GrRecordingContextPriv.h
+++ b/src/gpu/ganesh/GrRecordingContextPriv.h
@@ -18,7 +18,7 @@
#include "src/text/gpu/SDFTControl.h"
class GrImageInfo;
-class SkDeferredDisplayList;
+class GrDeferredDisplayList;
namespace skgpu {
class Swizzle;
}
@@ -64,7 +64,7 @@
GrThreadSafeCache* threadSafeCache() { return this->context()->threadSafeCache(); }
- void moveRenderTasksToDDL(SkDeferredDisplayList*);
+ void moveRenderTasksToDDL(GrDeferredDisplayList*);
/**
* Registers an object for flush-related callbacks. (See GrOnFlushCallbackObject.)
diff --git a/src/gpu/ganesh/GrRenderTargetProxy.cpp b/src/gpu/ganesh/GrRenderTargetProxy.cpp
index 9d40834..f899b58 100644
--- a/src/gpu/ganesh/GrRenderTargetProxy.cpp
+++ b/src/gpu/ganesh/GrRenderTargetProxy.cpp
@@ -114,7 +114,7 @@
// have an exact way of knowing whether the target will be able to use stencil, so we do
// the best we can: if a lazy GL proxy doesn't have a texture, then it might be a
// wrapped target without stencil, so we conservatively block stencil.
- // FIXME: skbug.com/11943: SkSurfaceCharacterization needs a "canUseStencil" flag.
+ // FIXME: skbug.com/11943: GrSurfaceCharacterization needs a "canUseStencil" flag.
return SkToBool(this->asTextureProxy());
} else {
// Otherwise the target will definitely not be wrapped. Ganesh is free to attach
diff --git a/src/core/SkSurfaceCharacterization.cpp b/src/gpu/ganesh/GrSurfaceCharacterization.cpp
similarity index 83%
rename from src/core/SkSurfaceCharacterization.cpp
rename to src/gpu/ganesh/GrSurfaceCharacterization.cpp
index 707c55b..c4f0430 100644
--- a/src/core/SkSurfaceCharacterization.cpp
+++ b/src/gpu/ganesh/GrSurfaceCharacterization.cpp
@@ -5,18 +5,21 @@
* found in the LICENSE file.
*/
-#include "include/core/SkSurfaceCharacterization.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
-#if defined(SK_GANESH)
+#include "include/core/SkColorSpace.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#ifdef SK_VULKAN
#include "include/gpu/vk/GrVkTypes.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
#endif
#ifdef SK_DEBUG
-void SkSurfaceCharacterization::validate() const {
+void GrSurfaceCharacterization::validate() const {
const GrCaps* caps = fContextInfo->priv().caps();
GrColorType grCT = SkColorTypeToGrColorType(this->colorType());
@@ -39,7 +42,7 @@
#endif
-bool SkSurfaceCharacterization::operator==(const SkSurfaceCharacterization& other) const {
+bool GrSurfaceCharacterization::operator==(const GrSurfaceCharacterization& other) const {
if (!this->isValid() || !other.isValid()) {
return false;
}
@@ -61,18 +64,18 @@
fSurfaceProps == other.fSurfaceProps;
}
-SkSurfaceCharacterization SkSurfaceCharacterization::createResized(int width, int height) const {
+GrSurfaceCharacterization GrSurfaceCharacterization::createResized(int width, int height) const {
const GrCaps* caps = fContextInfo->priv().caps();
if (!caps) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
if (width <= 0 || height <= 0 || width > caps->maxRenderTargetSize() ||
height > caps->maxRenderTargetSize()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
- return SkSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
+ return GrSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
fImageInfo.makeWH(width, height), fBackendFormat, fOrigin,
fSampleCnt, fIsTextureable, fIsMipMapped, fUsesGLFBO0,
fVkRTSupportsInputAttachment,
@@ -80,47 +83,47 @@
fIsProtected, fSurfaceProps);
}
-SkSurfaceCharacterization SkSurfaceCharacterization::createColorSpace(
+GrSurfaceCharacterization GrSurfaceCharacterization::createColorSpace(
sk_sp<SkColorSpace> cs) const {
if (!this->isValid()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
- return SkSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
+ return GrSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
fImageInfo.makeColorSpace(std::move(cs)), fBackendFormat,
fOrigin, fSampleCnt, fIsTextureable, fIsMipMapped, fUsesGLFBO0,
fVkRTSupportsInputAttachment,
fVulkanSecondaryCBCompatible, fIsProtected, fSurfaceProps);
}
-SkSurfaceCharacterization SkSurfaceCharacterization::createBackendFormat(
+GrSurfaceCharacterization GrSurfaceCharacterization::createBackendFormat(
SkColorType colorType,
const GrBackendFormat& backendFormat) const {
if (!this->isValid()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
SkImageInfo newII = fImageInfo.makeColorType(colorType);
- return SkSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes, newII, backendFormat,
+ return GrSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes, newII, backendFormat,
fOrigin, fSampleCnt, fIsTextureable, fIsMipMapped, fUsesGLFBO0,
fVkRTSupportsInputAttachment,
fVulkanSecondaryCBCompatible, fIsProtected, fSurfaceProps);
}
-SkSurfaceCharacterization SkSurfaceCharacterization::createFBO0(bool usesGLFBO0) const {
+GrSurfaceCharacterization GrSurfaceCharacterization::createFBO0(bool usesGLFBO0) const {
if (!this->isValid()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
// We can't create an FBO0 characterization that is textureable or has any non-gl specific flags
if (fIsTextureable == Textureable::kYes ||
fVkRTSupportsInputAttachment == VkRTSupportsInputAttachment::kYes ||
fVulkanSecondaryCBCompatible == VulkanSecondaryCBCompatible::kYes) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
- return SkSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
+ return GrSurfaceCharacterization(fContextInfo, fCacheMaxResourceBytes,
fImageInfo, fBackendFormat,
fOrigin, fSampleCnt, fIsTextureable, fIsMipMapped,
usesGLFBO0 ? UsesGLFBO0::kYes : UsesGLFBO0::kNo,
@@ -128,7 +131,7 @@
fVulkanSecondaryCBCompatible, fIsProtected, fSurfaceProps);
}
-bool SkSurfaceCharacterization::isCompatible(const GrBackendTexture& backendTex) const {
+bool GrSurfaceCharacterization::isCompatible(const GrBackendTexture& backendTex) const {
if (!this->isValid() || !backendTex.isValid()) {
return false;
}
@@ -177,6 +180,3 @@
return true;
}
-
-
-#endif
diff --git a/src/gpu/ganesh/surface/SkSurface_AndroidFactories.cpp b/src/gpu/ganesh/surface/SkSurface_AndroidFactories.cpp
index e3ad869..d1af3ed 100644
--- a/src/gpu/ganesh/surface/SkSurface_AndroidFactories.cpp
+++ b/src/gpu/ganesh/surface/SkSurface_AndroidFactories.cpp
@@ -13,13 +13,11 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkImage.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkSurfaceProps.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSurface.h"
@@ -29,6 +27,7 @@
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/base/SkTo.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkDevice.h"
#include "src/core/SkSurfacePriv.h"
diff --git a/src/gpu/ganesh/surface/SkSurface_Ganesh.cpp b/src/gpu/ganesh/surface/SkSurface_Ganesh.cpp
index 4d00008..e16c8a7 100644
--- a/src/gpu/ganesh/surface/SkSurface_Ganesh.cpp
+++ b/src/gpu/ganesh/surface/SkSurface_Ganesh.cpp
@@ -10,13 +10,10 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkImage.h"
-#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkSurfaceProps.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSurface.h"
@@ -26,6 +23,8 @@
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/base/SkTo.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkDevice.h"
#include "src/core/SkSurfacePriv.h"
@@ -244,7 +243,7 @@
return fDevice->wait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait);
}
-bool SkSurface_Ganesh::onCharacterize(SkSurfaceCharacterization* characterization) const {
+bool SkSurface_Ganesh::onCharacterize(GrSurfaceCharacterization* characterization) const {
auto direct = fDevice->recordingContext()->asDirectContext();
if (!direct) {
return false;
@@ -281,11 +280,11 @@
format,
readSurfaceView.origin(),
numSamples,
- SkSurfaceCharacterization::Textureable(SkToBool(readSurfaceView.asTextureProxy())),
- SkSurfaceCharacterization::MipMapped(mipmapped),
- SkSurfaceCharacterization::UsesGLFBO0(usesGLFBO0),
- SkSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
- SkSurfaceCharacterization::VulkanSecondaryCBCompatible(false),
+ GrSurfaceCharacterization::Textureable(SkToBool(readSurfaceView.asTextureProxy())),
+ GrSurfaceCharacterization::MipMapped(mipmapped),
+ GrSurfaceCharacterization::UsesGLFBO0(usesGLFBO0),
+ GrSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
+ GrSurfaceCharacterization::VulkanSecondaryCBCompatible(false),
isProtected,
this->props());
return true;
@@ -326,7 +325,7 @@
}
}
-bool SkSurface_Ganesh::onIsCompatible(const SkSurfaceCharacterization& characterization) const {
+bool SkSurface_Ganesh::onIsCompatible(const GrSurfaceCharacterization& characterization) const {
auto direct = fDevice->recordingContext()->asDirectContext();
if (!direct) {
return false;
@@ -394,7 +393,7 @@
characterization.surfaceProps() == fDevice->surfaceProps();
}
-bool SkSurface_Ganesh::onDraw(sk_sp<const SkDeferredDisplayList> ddl, SkIPoint offset) {
+bool SkSurface_Ganesh::draw(sk_sp<const GrDeferredDisplayList> ddl) {
if (!ddl || !this->isCompatible(ddl->characterization())) {
return false;
}
@@ -406,7 +405,7 @@
GrSurfaceProxyView view = fDevice->readSurfaceView();
- direct->priv().createDDLTask(std::move(ddl), view.asRenderTargetProxyRef(), offset);
+ direct->priv().createDDLTask(std::move(ddl), view.asRenderTargetProxyRef());
return true;
}
@@ -542,7 +541,7 @@
namespace SkSurfaces {
sk_sp<SkSurface> RenderTarget(GrRecordingContext* rContext,
- const SkSurfaceCharacterization& c,
+ const GrSurfaceCharacterization& c,
skgpu::Budgeted budgeted) {
if (!rContext || !c.isValid()) {
return nullptr;
@@ -801,3 +800,12 @@
} // namespace skgpu::ganesh
+#if !defined(SK_DISABLE_LEGACY_SKSURFACE_DISPLAYLIST)
+
+bool SkSurface::draw(sk_sp<const GrDeferredDisplayList> ddl, int xOffset, int yOffset) {
+ if (xOffset != 0 || yOffset != 0) {
+ return false;
+ }
+ return skgpu::ganesh::DrawDDL(this, ddl);
+}
+#endif
diff --git a/src/gpu/ganesh/surface/SkSurface_Ganesh.h b/src/gpu/ganesh/surface/SkSurface_Ganesh.h
index 21ccc46..f2d8834 100644
--- a/src/gpu/ganesh/surface/SkSurface_Ganesh.h
+++ b/src/gpu/ganesh/surface/SkSurface_Ganesh.h
@@ -18,23 +18,22 @@
#include "src/image/SkSurface_Base.h"
class GrBackendSemaphore;
+class GrDeferredDisplayList;
class GrRecordingContext;
+class GrSurfaceCharacterization;
class SkCanvas;
class SkCapabilities;
class SkColorSpace;
-class SkDeferredDisplayList;
class SkImage;
class SkPaint;
class SkPixmap;
class SkSurface;
-class SkSurfaceCharacterization;
enum GrSurfaceOrigin : int;
namespace skgpu {
namespace ganesh {
class Device;
}
} // namespace skgpu
-struct SkIPoint;
struct SkIRect;
struct SkISize;
@@ -79,14 +78,13 @@
bool onWait(int numSemaphores,
const GrBackendSemaphore* waitSemaphores,
bool deleteSemaphoresAfterWait) override;
- bool onCharacterize(SkSurfaceCharacterization*) const override;
- bool onIsCompatible(const SkSurfaceCharacterization&) const override;
+ bool onCharacterize(GrSurfaceCharacterization*) const override;
+ bool onIsCompatible(const GrSurfaceCharacterization&) const override;
void onDraw(SkCanvas* canvas,
SkScalar x,
SkScalar y,
const SkSamplingOptions&,
const SkPaint* paint) override;
- bool onDraw(sk_sp<const SkDeferredDisplayList>, SkIPoint offset) override;
sk_sp<const SkCapabilities> onCapabilities() override;
@@ -94,6 +92,7 @@
GrBackendTexture getBackendTexture(BackendHandleAccess);
GrBackendRenderTarget getBackendRenderTarget(BackendHandleAccess);
void resolveMSAA();
+ bool draw(sk_sp<const GrDeferredDisplayList>);
private:
sk_sp<skgpu::ganesh::Device> fDevice;
diff --git a/src/gpu/ganesh/surface/SkSurface_GaneshMtl.mm b/src/gpu/ganesh/surface/SkSurface_GaneshMtl.mm
index fea9e1f..aac5612 100644
--- a/src/gpu/ganesh/surface/SkSurface_GaneshMtl.mm
+++ b/src/gpu/ganesh/surface/SkSurface_GaneshMtl.mm
@@ -5,6 +5,7 @@
* found in the LICENSE file.
*/
+#include "include/core/SkColorSpace.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GrBackendSurface.h"
diff --git a/src/gpu/ganesh/vk/GrVkSecondaryCBDrawContext.cpp b/src/gpu/ganesh/vk/GrVkSecondaryCBDrawContext.cpp
index aa344a1..1e1ad28 100644
--- a/src/gpu/ganesh/vk/GrVkSecondaryCBDrawContext.cpp
+++ b/src/gpu/ganesh/vk/GrVkSecondaryCBDrawContext.cpp
@@ -7,12 +7,12 @@
#include "include/private/chromium/GrVkSecondaryCBDrawContext.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkImageInfo.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/vk/GrVkTypes.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "src/core/SkSurfacePriv.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
@@ -92,7 +92,7 @@
fDevice.reset();
}
-bool GrVkSecondaryCBDrawContext::characterize(SkSurfaceCharacterization* characterization) const {
+bool GrVkSecondaryCBDrawContext::characterize(GrSurfaceCharacterization* characterization) const {
auto direct = fDevice->recordingContext()->asDirectContext();
if (!direct) {
return false;
@@ -119,11 +119,11 @@
format,
readSurfaceView.origin(),
numSamples,
- SkSurfaceCharacterization::Textureable(false),
- SkSurfaceCharacterization::MipMapped(false),
- SkSurfaceCharacterization::UsesGLFBO0(false),
- SkSurfaceCharacterization::VkRTSupportsInputAttachment(false),
- SkSurfaceCharacterization::VulkanSecondaryCBCompatible(true),
+ GrSurfaceCharacterization::Textureable(false),
+ GrSurfaceCharacterization::MipMapped(false),
+ GrSurfaceCharacterization::UsesGLFBO0(false),
+ GrSurfaceCharacterization::VkRTSupportsInputAttachment(false),
+ GrSurfaceCharacterization::VulkanSecondaryCBCompatible(true),
isProtected,
this->props());
@@ -131,7 +131,7 @@
}
bool GrVkSecondaryCBDrawContext::isCompatible(
- const SkSurfaceCharacterization& characterization) const {
+ const GrSurfaceCharacterization& characterization) const {
auto dContext = fDevice->recordingContext()->asDirectContext();
if (!dContext) {
@@ -185,9 +185,9 @@
}
#ifndef SK_DDL_IS_UNIQUE_POINTER
-bool GrVkSecondaryCBDrawContext::draw(sk_sp<const SkDeferredDisplayList> ddl) {
+bool GrVkSecondaryCBDrawContext::draw(sk_sp<const GrDeferredDisplayList> ddl) {
#else
-bool GrVkSecondaryCBDrawContext::draw(const SkDeferredDisplayList* ddl) {
+bool GrVkSecondaryCBDrawContext::draw(const GrDeferredDisplayList* ddl) {
#endif
if (!ddl || !this->isCompatible(ddl->characterization())) {
return false;
@@ -200,6 +200,6 @@
GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
- direct->priv().createDDLTask(std::move(ddl), readSurfaceView.asRenderTargetProxyRef(), {0, 0});
+ direct->priv().createDDLTask(std::move(ddl), readSurfaceView.asRenderTargetProxyRef());
return true;
}
diff --git a/src/gpu/graphite/Surface_Graphite.cpp b/src/gpu/graphite/Surface_Graphite.cpp
index 832fd57..d2ea3c7 100644
--- a/src/gpu/graphite/Surface_Graphite.cpp
+++ b/src/gpu/graphite/Surface_Graphite.cpp
@@ -8,6 +8,7 @@
#include "src/gpu/graphite/Surface_Graphite.h"
#include "include/core/SkCapabilities.h"
+#include "include/core/SkColorSpace.h"
#include "include/gpu/graphite/BackendTexture.h"
#include "include/gpu/graphite/Recorder.h"
#include "include/gpu/graphite/Surface.h"
diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp
index d4cc662..9ece09a 100644
--- a/src/image/SkSurface.cpp
+++ b/src/image/SkSurface.cpp
@@ -11,7 +11,6 @@
#include "include/core/SkCanvas.h"
#include "include/core/SkCapabilities.h" // IWYU pragma: keep
#include "include/core/SkColorSpace.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPixmap.h"
@@ -32,7 +31,7 @@
class GrBackendSemaphore;
class GrRecordingContext; // IWYU pragma: keep
class SkPaint;
-class SkSurfaceCharacterization;
+class GrSurfaceCharacterization;
namespace skgpu { namespace graphite { class Recorder; } }
SkSurfaceProps::SkSurfaceProps() : fFlags(0), fPixelGeometry(kUnknown_SkPixelGeometry) {}
@@ -203,22 +202,14 @@
return asSB(this)->onWait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait);
}
-bool SkSurface::characterize(SkSurfaceCharacterization* characterization) const {
+bool SkSurface::characterize(GrSurfaceCharacterization* characterization) const {
return asConstSB(this)->onCharacterize(characterization);
}
-bool SkSurface::isCompatible(const SkSurfaceCharacterization& characterization) const {
+bool SkSurface::isCompatible(const GrSurfaceCharacterization& characterization) const {
return asConstSB(this)->onIsCompatible(characterization);
}
-bool SkSurface::draw(sk_sp<const SkDeferredDisplayList> ddl, int xOffset, int yOffset) {
- if (xOffset != 0 || yOffset != 0) {
- return false; // the offsets currently aren't supported
- }
-
- return asSB(this)->onDraw(std::move(ddl), { xOffset, yOffset });
-}
-
#if !defined(SK_DISABLE_LEGACY_SKSURFACE_FLUSH) && !defined(SK_GANESH)
void SkSurface::flush() {}
void SkSurface::flushAndSubmit(bool syncCpu) {}
diff --git a/src/image/SkSurface_Base.cpp b/src/image/SkSurface_Base.cpp
index 3ce4120..d2d4943 100644
--- a/src/image/SkSurface_Base.cpp
+++ b/src/image/SkSurface_Base.cpp
@@ -10,6 +10,7 @@
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkCapabilities.h"
+#include "include/core/SkColorSpace.h" // IWYU pragma: keep
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPixmap.h"
@@ -24,7 +25,6 @@
#include <memory>
class GrRecordingContext;
-class SkColorSpace;
class SkPaint;
class SkSurfaceProps;
namespace skgpu { namespace graphite { class Recorder; } }
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index b1958a9..f007dd0 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -9,9 +9,7 @@
#define SkSurface_Base_DEFINED
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayList.h" // IWYU pragma: keep
#include "include/core/SkImage.h"
-#include "include/core/SkPoint.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkScalar.h"
@@ -28,7 +26,7 @@
class SkColorSpace;
class SkPaint;
class SkPixmap;
-class SkSurfaceCharacterization;
+class GrSurfaceCharacterization;
class SkSurfaceProps;
enum GrSurfaceOrigin : int;
enum SkYUVColorSpace : int;
@@ -160,11 +158,8 @@
return false;
}
- virtual bool onCharacterize(SkSurfaceCharacterization*) const { return false; }
- virtual bool onIsCompatible(const SkSurfaceCharacterization&) const { return false; }
- virtual bool onDraw(sk_sp<const SkDeferredDisplayList>, SkIPoint offset) {
- return false;
- }
+ virtual bool onCharacterize(GrSurfaceCharacterization*) const { return false; }
+ virtual bool onIsCompatible(const GrSurfaceCharacterization&) const { return false; }
// TODO: Remove this (make it pure virtual) after updating Android (which has a class derived
// from SkSurface_Base).
diff --git a/tests/DeferredDisplayListTest.cpp b/tests/DeferredDisplayListTest.cpp
index 2e290f6..1956e99 100644
--- a/tests/DeferredDisplayListTest.cpp
+++ b/tests/DeferredDisplayListTest.cpp
@@ -11,8 +11,6 @@
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPromiseImageTexture.h"
@@ -20,7 +18,6 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
@@ -31,8 +28,11 @@
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
-#include "src/core/SkDeferredDisplayListPriv.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "src/gpu/ganesh/GrCaps.h"
+#include "src/gpu/ganesh/GrDeferredDisplayListPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
@@ -189,11 +189,11 @@
return changed;
}
- SkSurfaceCharacterization createCharacterization(GrDirectContext* dContext) const {
+ GrSurfaceCharacterization createCharacterization(GrDirectContext* dContext) const {
size_t maxResourceBytes = dContext->getResourceCacheLimit();
if (!dContext->colorTypeSupportedAsSurface(fColorType)) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
// Note that Ganesh doesn't make use of the SkImageInfo's alphaType
@@ -203,10 +203,10 @@
GrBackendFormat backendFormat = dContext->defaultBackendFormat(fColorType,
GrRenderable::kYes);
if (!backendFormat.isValid()) {
- return SkSurfaceCharacterization();
+ return GrSurfaceCharacterization();
}
- SkSurfaceCharacterization c = dContext->threadSafeProxy()->createCharacterization(
+ GrSurfaceCharacterization c = dContext->threadSafeProxy()->createCharacterization(
maxResourceBytes, ii, backendFormat, fSampleCount,
fOrigin, fSurfaceProps, fShouldCreateMipMaps,
fUsesGLFBO0, fIsTextureable, fIsProtected,
@@ -216,11 +216,11 @@
}
// Create a DDL whose characterization captures the current settings
- sk_sp<SkDeferredDisplayList> createDDL(GrDirectContext* dContext) const {
- SkSurfaceCharacterization c = this->createCharacterization(dContext);
+ sk_sp<GrDeferredDisplayList> createDDL(GrDirectContext* dContext) const {
+ GrSurfaceCharacterization c = this->createCharacterization(dContext);
SkAssertResult(c.isValid());
- SkDeferredDisplayListRecorder r(c);
+ GrDeferredDisplayListRecorder r(c);
SkCanvas* canvas = r.getCanvas();
if (!canvas) {
return nullptr;
@@ -232,7 +232,7 @@
// Create the surface with the current set of parameters
sk_sp<SkSurface> make(GrDirectContext* dContext) const {
- const SkSurfaceCharacterization c = this->createCharacterization(dContext);
+ const GrSurfaceCharacterization c = this->createCharacterization(dContext);
#ifdef SK_GL
if (fUsesGLFBO0) {
@@ -305,7 +305,7 @@
#ifdef SK_VULKAN
sk_sp<GrVkSecondaryCBDrawContext> makeVkSCB(GrDirectContext* dContext) {
- const SkSurfaceCharacterization c = this->createCharacterization(dContext);
+ const GrSurfaceCharacterization c = this->createCharacterization(dContext);
SkImageInfo imageInfo = SkImageInfo::Make({fWidth, fHeight},
{fColorType, kPremul_SkAlphaType, fColorSpace});
GrVkDrawableInfo vkInfo;
@@ -350,7 +350,7 @@
SurfaceParameters params1(context);
bool didModify1 = i >= 0 && params1.modify(i);
- SkSurfaceCharacterization char1 = params1.createCharacterization(context);
+ GrSurfaceCharacterization char1 = params1.createCharacterization(context);
if (!char1.isValid()) {
continue; // can happen on some platforms (ChromeOS)
}
@@ -359,7 +359,7 @@
SurfaceParameters params2(context);
bool didModify2 = j >= 0 && params2.modify(j);
- SkSurfaceCharacterization char2 = params2.createCharacterization(context);
+ GrSurfaceCharacterization char2 = params2.createCharacterization(context);
if (!char2.isValid()) {
continue; // can happen on some platforms (ChromeOS)
}
@@ -375,10 +375,10 @@
{
SurfaceParameters params(context);
- SkSurfaceCharacterization valid = params.createCharacterization(context);
+ GrSurfaceCharacterization valid = params.createCharacterization(context);
SkASSERT(valid.isValid());
- SkSurfaceCharacterization inval1, inval2;
+ GrSurfaceCharacterization inval1, inval2;
SkASSERT(!inval1.isValid() && !inval2.isValid());
REPORTER_ASSERT(reporter, inval1 != inval2);
@@ -388,7 +388,7 @@
}
////////////////////////////////////////////////////////////////////////////////
-// This tests SkSurfaceCharacterization/SkSurface compatibility
+// This tests GrSurfaceCharacterization/SkSurface compatibility
void DDLSurfaceCharacterizationTestImpl(GrDirectContext* dContext, skiatest::Reporter* reporter) {
// Create a bitmap that we can readback into
SkImageInfo imageInfo = SkImageInfo::Make(64, 64, kRGBA_8888_SkColorType,
@@ -396,7 +396,7 @@
SkBitmap bitmap;
bitmap.allocPixels(imageInfo);
- sk_sp<SkDeferredDisplayList> ddl;
+ sk_sp<GrDeferredDisplayList> ddl;
// First, create a DDL using the stock SkSurface parameters
{
@@ -413,7 +413,7 @@
return;
}
- REPORTER_ASSERT(reporter, s->draw(ddl));
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
s->readPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
dContext->flush();
@@ -431,7 +431,7 @@
continue;
}
- REPORTER_ASSERT(reporter, !s->draw(ddl),
+ REPORTER_ASSERT(reporter, !skgpu::ganesh::DrawDDL(s, ddl),
"DDLSurfaceCharacterizationTest failed on parameter: %d\n", i);
dContext->flush();
}
@@ -445,22 +445,22 @@
size_t maxResourceBytes = dContext->getResourceCacheLimit();
dContext->setResourceCacheLimit(maxResourceBytes/2);
- REPORTER_ASSERT(reporter, !s->draw(ddl));
+ REPORTER_ASSERT(reporter, !skgpu::ganesh::DrawDDL(s, ddl));
// DDL TODO: once proxies/ops can be de-instantiated we can re-enable these tests.
// For now, DDLs are drawn once.
#if 0
// resource limits >= those at characterization time are accepted
context->setResourceCacheLimits(2*maxResourceCount, maxResourceBytes);
- REPORTER_ASSERT(reporter, s->draw(ddl));
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
s->readPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
context->setResourceCacheLimits(maxResourceCount, 2*maxResourceBytes);
- REPORTER_ASSERT(reporter, s->draw(ddl));
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
s->readPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
context->setResourceCacheLimits(maxResourceCount, maxResourceBytes);
- REPORTER_ASSERT(reporter, s->draw(ddl));
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
s->readPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
#endif
@@ -474,7 +474,8 @@
sk_sp<SkSurface> s = params.make(dContext);
if (s) {
- REPORTER_ASSERT(reporter, !s->draw(ddl)); // bc the DDL was made w/ textureability
+ // bc the DDL was made w/ textureability
+ REPORTER_ASSERT(reporter, !skgpu::ganesh::DrawDDL(s, ddl));
dContext->flush();
}
@@ -485,7 +486,7 @@
SkImageInfo ii = SkImageInfo::MakeN32(64, 64, kOpaque_SkAlphaType);
sk_sp<SkSurface> rasterSurface = SkSurfaces::Raster(ii);
- SkSurfaceCharacterization c;
+ GrSurfaceCharacterization c;
REPORTER_ASSERT(reporter, !rasterSurface->characterize(&c));
}
@@ -498,19 +499,19 @@
return;
}
- SkSurfaceCharacterization char0;
+ GrSurfaceCharacterization char0;
SkAssertResult(s->characterize(&char0));
// Too small
- SkSurfaceCharacterization char1 = char0.createResized(-1, -1);
+ GrSurfaceCharacterization char1 = char0.createResized(-1, -1);
REPORTER_ASSERT(reporter, !char1.isValid());
// Too large
- SkSurfaceCharacterization char2 = char0.createResized(1000000, 32);
+ GrSurfaceCharacterization char2 = char0.createResized(1000000, 32);
REPORTER_ASSERT(reporter, !char2.isValid());
// Just right
- SkSurfaceCharacterization char3 = char0.createResized(32, 32);
+ GrSurfaceCharacterization char3 = char0.createResized(32, 32);
REPORTER_ASSERT(reporter, char3.isValid());
REPORTER_ASSERT(reporter, 32 == char3.width());
REPORTER_ASSERT(reporter, 32 == char3.height());
@@ -525,7 +526,7 @@
return;
}
- SkSurfaceCharacterization char0;
+ GrSurfaceCharacterization char0;
SkAssertResult(s->characterize(&char0));
// The default params create an sRGB color space
@@ -535,14 +536,14 @@
{
sk_sp<SkColorSpace> newCS = SkColorSpace::MakeSRGBLinear();
- SkSurfaceCharacterization char1 = char0.createColorSpace(std::move(newCS));
+ GrSurfaceCharacterization char1 = char0.createColorSpace(std::move(newCS));
REPORTER_ASSERT(reporter, char1.isValid());
REPORTER_ASSERT(reporter, !char1.colorSpace()->isSRGB());
REPORTER_ASSERT(reporter, char1.colorSpace()->gammaIsLinear());
}
{
- SkSurfaceCharacterization char2 = char0.createColorSpace(nullptr);
+ GrSurfaceCharacterization char2 = char0.createColorSpace(nullptr);
REPORTER_ASSERT(reporter, char2.isValid());
REPORTER_ASSERT(reporter, !char2.colorSpace());
}
@@ -550,9 +551,9 @@
{
sk_sp<SkColorSpace> newCS = SkColorSpace::MakeSRGBLinear();
- SkSurfaceCharacterization invalid;
+ GrSurfaceCharacterization invalid;
REPORTER_ASSERT(reporter, !invalid.isValid());
- SkSurfaceCharacterization stillInvalid = invalid.createColorSpace(std::move(newCS));
+ GrSurfaceCharacterization stillInvalid = invalid.createColorSpace(std::move(newCS));
REPORTER_ASSERT(reporter, !stillInvalid.isValid());
}
}
@@ -566,7 +567,7 @@
return;
}
- SkSurfaceCharacterization char0;
+ GrSurfaceCharacterization char0;
SkAssertResult(s->characterize(&char0));
// The default params create a renderable RGBA8 surface
@@ -579,12 +580,12 @@
GrRenderable::kYes);
if (newBackendFormat.isValid()) {
- SkSurfaceCharacterization char1 = char0.createBackendFormat(kRGB_565_SkColorType,
+ GrSurfaceCharacterization char1 = char0.createBackendFormat(kRGB_565_SkColorType,
newBackendFormat);
REPORTER_ASSERT(reporter, char1.isValid());
REPORTER_ASSERT(reporter, char1.backendFormat() == newBackendFormat);
- SkSurfaceCharacterization invalid;
+ GrSurfaceCharacterization invalid;
REPORTER_ASSERT(reporter, !invalid.isValid());
auto stillInvalid = invalid.createBackendFormat(kRGB_565_SkColorType,
newBackendFormat);
@@ -604,22 +605,22 @@
return;
}
- SkSurfaceCharacterization char0;
+ GrSurfaceCharacterization char0;
SkAssertResult(s->characterize(&char0));
// The default params create a non-FBO0 surface
REPORTER_ASSERT(reporter, !char0.usesGLFBO0());
{
- SkSurfaceCharacterization char1 = char0.createFBO0(true);
+ GrSurfaceCharacterization char1 = char0.createFBO0(true);
REPORTER_ASSERT(reporter, char1.isValid());
REPORTER_ASSERT(reporter, char1.usesGLFBO0());
}
{
- SkSurfaceCharacterization invalid;
+ GrSurfaceCharacterization invalid;
REPORTER_ASSERT(reporter, !invalid.isValid());
- SkSurfaceCharacterization stillInvalid = invalid.createFBO0(true);
+ GrSurfaceCharacterization stillInvalid = invalid.createFBO0(true);
REPORTER_ASSERT(reporter, !stillInvalid.isValid());
}
}
@@ -665,7 +666,7 @@
/* not-FBO0 & not- */ { false, false, false, true }
};
- SkSurfaceCharacterization characterizations[4];
+ GrSurfaceCharacterization characterizations[4];
sk_sp<SkSurface> surfaces[4];
int index = 0;
@@ -712,10 +713,10 @@
SurfaceParameters params(dContext);
params.modify(SurfaceParameters::kVkSCBCount);
- SkSurfaceCharacterization characterization = params.createCharacterization(dContext);
+ GrSurfaceCharacterization characterization = params.createCharacterization(dContext);
REPORTER_ASSERT(reporter, characterization.isValid());
- sk_sp<SkDeferredDisplayList> ddl = params.createDDL(dContext);
+ sk_sp<GrDeferredDisplayList> ddl = params.createDDL(dContext);
REPORTER_ASSERT(reporter, ddl.get());
sk_sp<GrVkSecondaryCBDrawContext> scbDrawContext = params.makeVkSCB(dContext);
@@ -766,7 +767,7 @@
bitmap.allocPixels(imageInfo);
for (bool textureability : { true, false }) {
- sk_sp<SkDeferredDisplayList> ddl;
+ sk_sp<GrDeferredDisplayList> ddl;
// First, create a DDL w/o textureability (and thus no mipmaps). TODO: once we have
// reusable DDLs, move this outside of the loop.
@@ -795,7 +796,7 @@
continue;
}
- REPORTER_ASSERT(reporter, s->draw(ddl));
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
s->readPixels(imageInfo, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
context->flush();
@@ -806,7 +807,7 @@
GrDirectContext* dContext,
const SurfaceParameters& params) {
{
- const SkSurfaceCharacterization c = params.createCharacterization(dContext);
+ const GrSurfaceCharacterization c = params.createCharacterization(dContext);
if (!c.isValid()) {
sk_sp<SkSurface> tmp = params.make(dContext);
@@ -816,7 +817,7 @@
}
}
- const SkSurfaceCharacterization c = params.createCharacterization(dContext);
+ const GrSurfaceCharacterization c = params.createCharacterization(dContext);
{
sk_sp<SkSurface> s = params.make(dContext);
REPORTER_ASSERT(reporter, s);
@@ -844,8 +845,8 @@
}
////////////////////////////////////////////////////////////////////////////////
-// This tests the SkSurfaces::RenderTarget variants that take an SkSurfaceCharacterization.
-// In particular, the SkSurface, backendTexture and SkSurfaceCharacterization
+// This tests the SkSurfaces::RenderTarget variants that take a GrSurfaceCharacterization.
+// In particular, the SkSurface, backendTexture and GrSurfaceCharacterization
// should always be compatible.
void DDLMakeRenderTargetTestImpl(GrDirectContext* dContext, skiatest::Reporter* reporter) {
for (int i = -1; i < SurfaceParameters::kNumParams; ++i) {
@@ -926,10 +927,10 @@
return;
}
- SkSurfaceCharacterization c;
+ GrSurfaceCharacterization c;
SkAssertResult(s->characterize(&c));
- SkDeferredDisplayListRecorder recorder(c);
+ GrDeferredDisplayListRecorder recorder(c);
SkCanvas* canvas = recorder.getCanvas();
SkASSERT(canvas);
@@ -965,19 +966,19 @@
SkImageInfo ii = SkImageInfo::MakeN32Premul(32, 32);
sk_sp<SkSurface> s = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kNo, ii);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
SkAssertResult(s->characterize(&characterization));
// never calling getCanvas means the backing surface is never allocated
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
}
{
- SkSurfaceCharacterization invalid;
+ GrSurfaceCharacterization invalid;
- SkDeferredDisplayListRecorder recorder(invalid);
+ GrDeferredDisplayListRecorder recorder(invalid);
- const SkSurfaceCharacterization c = recorder.characterization();
+ const GrSurfaceCharacterization c = recorder.characterization();
REPORTER_ASSERT(reporter, !c.isValid());
REPORTER_ASSERT(reporter, !recorder.getCanvas());
REPORTER_ASSERT(reporter, !recorder.detach());
@@ -1005,7 +1006,7 @@
SkImageInfo ii = SkImageInfo::Make(width, height, ct,
kPremul_SkAlphaType, nullptr);
- SkSurfaceCharacterization c = proxy->createCharacterization(
+ GrSurfaceCharacterization c = proxy->createCharacterization(
maxResourceBytes, ii, backendFormat, 1,
kBottomLeft_GrSurfaceOrigin, surfaceProps, false,
willUseGLFBO0, isTextureable, prot,
@@ -1119,7 +1120,7 @@
SkImageInfo ii = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
sk_sp<SkSurface> s = SkSurfaces::RenderTarget(context, skgpu::Budgeted::kNo, ii);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
SkAssertResult(s->characterize(&characterization));
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeFromInfo(context, ii);
@@ -1131,10 +1132,10 @@
FulfillInfo fulfillInfo;
fulfillInfo.fTex = SkPromiseImageTexture::Make(mbet->texture());
- sk_sp<SkDeferredDisplayList> ddl;
+ sk_sp<GrDeferredDisplayList> ddl;
{
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
GrBackendFormat format = context->defaultBackendFormat(kRGBA_8888_SkColorType,
GrRenderable::kNo);
@@ -1162,7 +1163,7 @@
context->flushAndSubmit();
- s->draw(ddl);
+ REPORTER_ASSERT(reporter, skgpu::ganesh::DrawDDL(s, ddl));
GrFlushInfo flushInfo;
context->flush(s, SkSurfaces::BackendSurfaceAccess::kPresent, flushInfo);
@@ -1191,10 +1192,10 @@
SkBitmap bitmap;
bitmap.allocPixels(ii);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
SkAssertResult(s->characterize(&characterization));
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
SkCanvas* canvas1 = recorder.getCanvas();
@@ -1203,7 +1204,7 @@
canvas1->save();
canvas1->clipRect(SkRect::MakeXYWH(8, 8, 16, 16));
- sk_sp<SkDeferredDisplayList> ddl1 = recorder.detach();
+ sk_sp<GrDeferredDisplayList> ddl1 = recorder.detach();
SkCanvas* canvas2 = recorder.getCanvas();
@@ -1211,7 +1212,7 @@
p.setColor(SK_ColorGREEN);
canvas2->drawRect(SkRect::MakeWH(32, 32), p);
- sk_sp<SkDeferredDisplayList> ddl2 = recorder.detach();
+ sk_sp<GrDeferredDisplayList> ddl2 = recorder.detach();
REPORTER_ASSERT(reporter, ddl1->priv().lazyProxyData());
REPORTER_ASSERT(reporter, ddl2->priv().lazyProxyData());
@@ -1220,8 +1221,8 @@
// lazy proxy are all different between the two DDLs
REPORTER_ASSERT(reporter, ddl1->priv().lazyProxyData() != ddl2->priv().lazyProxyData());
- s->draw(ddl1);
- s->draw(ddl2);
+ skgpu::ganesh::DrawDDL(s, ddl1);
+ skgpu::ganesh::DrawDDL(s, ddl2);
// Make sure the clipRect from DDL1 didn't percolate into DDL2
s->readPixels(ii, bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
@@ -1254,10 +1255,10 @@
SkImageInfo ii = SkImageInfo::MakeN32Premul(32, 32);
sk_sp<SkSurface> s = SkSurfaces::RenderTarget(context, skgpu::Budgeted::kNo, ii);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
SkAssertResult(s->characterize(&characterization));
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
for (GrGLenum target : { GR_GL_TEXTURE_EXTERNAL, GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_2D } ) {
for (auto mipmapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
diff --git a/tests/GrDDLImageTest.cpp b/tests/GrDDLImageTest.cpp
index 012a86e..9ae143c 100644
--- a/tests/GrDDLImageTest.cpp
+++ b/tests/GrDDLImageTest.cpp
@@ -14,7 +14,6 @@
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSurface.h"
@@ -22,6 +21,7 @@
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
@@ -58,7 +58,7 @@
// Texture image:
auto surf = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kNo, ii);
- SkSurfaceCharacterization sc;
+ GrSurfaceCharacterization sc;
REPORTER_ASSERT(reporter, surf->characterize(&sc));
GrBackendTexture tex = dContext->createBackendTexture(ii.width(),
ii.height(),
diff --git a/tests/GrThreadSafeCacheTest.cpp b/tests/GrThreadSafeCacheTest.cpp
index ca0b131..59e255e 100644
--- a/tests/GrThreadSafeCacheTest.cpp
+++ b/tests/GrThreadSafeCacheTest.cpp
@@ -13,8 +13,6 @@
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
@@ -23,7 +21,6 @@
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
@@ -35,6 +32,9 @@
#include "include/private/SkColorData.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMalloc.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/base/SkRandom.h"
#include "src/core/SkMessageBus.h"
@@ -178,13 +178,13 @@
fDst = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kNo, default_ii(kImageWH));
SkAssertResult(fDst);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
SkAssertResult(fDst->characterize(&characterization));
- fRecorder1 = std::make_unique<SkDeferredDisplayListRecorder>(characterization);
+ fRecorder1 = std::make_unique<GrDeferredDisplayListRecorder>(characterization);
this->ddlCanvas1()->clear(SkColors::kWhite);
- fRecorder2 = std::make_unique<SkDeferredDisplayListRecorder>(characterization);
+ fRecorder2 = std::make_unique<GrDeferredDisplayListRecorder>(characterization);
this->ddlCanvas2()->clear(SkColors::kWhite);
fDst->getCanvas()->clear(SkColors::kWhite);
@@ -203,9 +203,9 @@
SkCanvas* liveCanvas() { return fDst ? fDst->getCanvas() : nullptr; }
SkCanvas* ddlCanvas1() { return fRecorder1 ? fRecorder1->getCanvas() : nullptr; }
- sk_sp<SkDeferredDisplayList> snap1() {
+ sk_sp<GrDeferredDisplayList> snap1() {
if (fRecorder1) {
- sk_sp<SkDeferredDisplayList> tmp = fRecorder1->detach();
+ sk_sp<GrDeferredDisplayList> tmp = fRecorder1->detach();
fRecorder1 = nullptr;
return tmp;
}
@@ -213,9 +213,9 @@
return nullptr;
}
SkCanvas* ddlCanvas2() { return fRecorder2 ? fRecorder2->getCanvas() : nullptr; }
- sk_sp<SkDeferredDisplayList> snap2() {
+ sk_sp<GrDeferredDisplayList> snap2() {
if (fRecorder2) {
- sk_sp<SkDeferredDisplayList> tmp = fRecorder2->detach();
+ sk_sp<GrDeferredDisplayList> tmp = fRecorder2->detach();
fRecorder2 = nullptr;
return tmp;
}
@@ -427,14 +427,14 @@
return this->checkImage(reporter, fDst);
}
- bool checkImage(skiatest::Reporter* reporter, sk_sp<SkDeferredDisplayList> ddl) {
+ bool checkImage(skiatest::Reporter* reporter, sk_sp<GrDeferredDisplayList> ddl) {
sk_sp<SkSurface> tmp =
SkSurfaces::RenderTarget(fDContext, skgpu::Budgeted::kNo, default_ii(kImageWH));
if (!tmp) {
return false;
}
- if (!tmp->draw(std::move(ddl))) {
+ if (!skgpu::ganesh::DrawDDL(tmp, std::move(ddl))) {
return false;
}
@@ -465,8 +465,8 @@
GrThreadSafeCache::IsNewerBetter fIsNewerBetter;
sk_sp<SkSurface> fDst;
- std::unique_ptr<SkDeferredDisplayListRecorder> fRecorder1;
- std::unique_ptr<SkDeferredDisplayListRecorder> fRecorder2;
+ std::unique_ptr<GrDeferredDisplayListRecorder> fRecorder1;
+ std::unique_ptr<GrDeferredDisplayListRecorder> fRecorder2;
};
class GrThreadSafeVertexTestOp : public GrDrawOp {
@@ -1092,12 +1092,12 @@
TestHelper helper(dContext);
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(nullptr, kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas2(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, (helper.*check)(nullptr, kImageWH,
/*hits*/ 1, /*misses*/ 1, /*refs*/ 2, kNoID));
@@ -1141,12 +1141,12 @@
TestHelper helper(dContext);
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(nullptr, kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas2(), 2*kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, (helper.*check)(nullptr, 2*kImageWH,
/*hits*/ 0, /*misses*/ 2, /*refs*/ 1, kNoID));
@@ -1196,7 +1196,7 @@
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 1, /*misses*/ 1, /*refs*/ 2, kNoID));
@@ -1211,7 +1211,7 @@
dContext->abandonContext(); // This should exercise dropAllRefs
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, helper.numCacheEntries() == 0);
@@ -1247,7 +1247,7 @@
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 1, /*misses*/ 1, /*refs*/ 2, kNoID));
@@ -1262,7 +1262,7 @@
dContext->releaseResourcesAndAbandonContext(); // This should hit dropAllRefs
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, helper.numCacheEntries() == 0);
@@ -1304,7 +1304,7 @@
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 1, /*misses*/ 1, /*refs*/ 2, kNoID));
@@ -1313,7 +1313,7 @@
/*hits*/ 1, /*misses*/ 2, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas2(), 2*kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas2(), 2*kImageWH,
/*hits*/ 2, /*misses*/ 2, /*refs*/ 2, kNoID));
@@ -1428,7 +1428,7 @@
REPORTER_ASSERT(reporter, (helper.*check)(helper.liveCanvas(), kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 1, /*misses*/ 1, /*refs*/ 2, kNoID));
@@ -1481,7 +1481,7 @@
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
std::this_thread::sleep_for(std::chrono::milliseconds(5));
auto firstTime = skgpu::StdSteadyClock::now();
@@ -1491,7 +1491,7 @@
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas2(), 2*kImageWH,
/*hits*/ 0, /*misses*/ 2, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
ddl1 = nullptr;
ddl2 = nullptr;
@@ -1572,7 +1572,7 @@
(helper.*addAccess)(helper.ddlCanvas1(), kImageWH, kNoID, false, false);
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas1(), kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
REPORTER_ASSERT(reporter, helper.numCacheEntries() == 1);
@@ -1592,7 +1592,7 @@
(helper.*addAccess)(helper.ddlCanvas2(), kImageWH, kNoID, false, false);
REPORTER_ASSERT(reporter, (helper.*check)(helper.ddlCanvas2(), kImageWH,
/*hits*/ 0, /*misses*/ 2, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, helper.numCacheEntries() == 1);
@@ -1640,7 +1640,7 @@
helper.addVertAccess(helper.ddlCanvas1(), kImageWH, kNoID, false, false, &op1);
REPORTER_ASSERT(reporter, helper.checkVert(helper.ddlCanvas1(), kImageWH,
/*hits*/ 0, /*misses*/ 1, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl1 = helper.snap1();
+ sk_sp<GrDeferredDisplayList> ddl1 = helper.snap1();
{
REPORTER_ASSERT(reporter, helper.numCacheEntries() == 1);
@@ -1651,7 +1651,7 @@
helper.addVertAccess(helper.ddlCanvas2(), kImageWH, kNoID, /* failLookup */ true, false, &op2);
REPORTER_ASSERT(reporter, helper.checkVert(helper.ddlCanvas2(), kImageWH,
/*hits*/ 0, /*misses*/ 2, /*refs*/ 1, kNoID));
- sk_sp<SkDeferredDisplayList> ddl2 = helper.snap2();
+ sk_sp<GrDeferredDisplayList> ddl2 = helper.snap2();
REPORTER_ASSERT(reporter, op1->vertexData() != op2->vertexData());
diff --git a/tests/PromiseImageTest.cpp b/tests/PromiseImageTest.cpp
index 4738312..7971d75 100644
--- a/tests/PromiseImageTest.cpp
+++ b/tests/PromiseImageTest.cpp
@@ -11,7 +11,6 @@
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPaint.h"
@@ -29,6 +28,7 @@
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/private/base/SkTArray.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
@@ -406,11 +406,11 @@
int fFulfillCount = 0;
int fReleaseCount = 0;
} counts;
- auto fulfill = [](SkDeferredDisplayListRecorder::PromiseImageTextureContext ctx) {
+ auto fulfill = [](GrDeferredDisplayListRecorder::PromiseImageTextureContext ctx) {
++static_cast<Counts*>(ctx)->fFulfillCount;
return sk_sp<SkPromiseImageTexture>();
};
- auto release = [](SkDeferredDisplayListRecorder::PromiseImageTextureContext ctx) {
+ auto release = [](GrDeferredDisplayListRecorder::PromiseImageTextureContext ctx) {
++static_cast<Counts*>(ctx)->fReleaseCount;
};
GrSurfaceOrigin texOrigin = kTopLeft_GrSurfaceOrigin;
diff --git a/tests/WrappedSurfaceCopyOnWriteTest.cpp b/tests/WrappedSurfaceCopyOnWriteTest.cpp
index d749361..5b923ca 100644
--- a/tests/WrappedSurfaceCopyOnWriteTest.cpp
+++ b/tests/WrappedSurfaceCopyOnWriteTest.cpp
@@ -10,19 +10,19 @@
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrTypes.h"
#include "include/private/SkColorData.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkAutoPixmapStorage.h"
#include "src/gpu/SkBackingFit.h"
@@ -89,9 +89,9 @@
img = surf->makeImageSnapshot();
REPORTER_ASSERT(reporter, imageProxyID(img) != imageID);
- SkSurfaceCharacterization characterization;
+ GrSurfaceCharacterization characterization;
REPORTER_ASSERT(reporter, surf->characterize(&characterization));
- SkDeferredDisplayListRecorder recorder(characterization);
+ GrDeferredDisplayListRecorder recorder(characterization);
// Using an image from a direct context on a recording context should trigger using the copy.
surf = makeDirectBackendSurface();
diff --git a/tests/graphite/ImageProviderTest.cpp b/tests/graphite/ImageProviderTest.cpp
index 50f8274..ffe9dae 100644
--- a/tests/graphite/ImageProviderTest.cpp
+++ b/tests/graphite/ImageProviderTest.cpp
@@ -8,6 +8,7 @@
#include "tests/Test.h"
#include "include/core/SkBitmap.h"
+#include "include/core/SkColorSpace.h"
#include "include/core/SkImageGenerator.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkSpan.h"
diff --git a/tests/graphite/MutableImagesTest.cpp b/tests/graphite/MutableImagesTest.cpp
index c9d456f..d552b51 100644
--- a/tests/graphite/MutableImagesTest.cpp
+++ b/tests/graphite/MutableImagesTest.cpp
@@ -7,6 +7,7 @@
#include "tests/Test.h"
+#include "include/core/SkColorSpace.h"
#include "include/core/SkImage.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/graphite/BackendTexture.h"
diff --git a/toolchain/linux_trampolines/clang_trampoline_linux.sh b/toolchain/linux_trampolines/clang_trampoline_linux.sh
index e81086a..2278611 100755
--- a/toolchain/linux_trampolines/clang_trampoline_linux.sh
+++ b/toolchain/linux_trampolines/clang_trampoline_linux.sh
@@ -105,7 +105,7 @@
"src/gpu/ganesh/GrCanvas.cpp"
"src/gpu/ganesh/GrCaps.cpp"
"src/gpu/ganesh/GrContext_Base.cpp"
- "src/gpu/ganesh/GrDefaultGeoProcFactory.cpp"
+ "src/gpu/ganesh/GrDef"
"src/gpu/ganesh/GrDirectContext.cpp"
"src/gpu/ganesh/GrFragmentProcessors.cpp"
"src/gpu/ganesh/GrImageContext.cpp"
@@ -114,6 +114,7 @@
"src/gpu/ganesh/GrRecordingContext.cpp"
"src/gpu/ganesh/GrRenderTargetProxy.cpp"
"src/gpu/ganesh/GrResourceProvider.cpp"
+ "src/gpu/ganesh/GrSurfaceCharacterization.cpp"
"src/gpu/ganesh/GrSurfaceProxy.cpp"
"src/gpu/ganesh/GrSurfaceProxyView.cpp"
"src/gpu/ganesh/GrTextureProxy.cpp"
diff --git a/tools/DDLPromiseImageHelper.cpp b/tools/DDLPromiseImageHelper.cpp
index 850696b..75a4a64 100644
--- a/tools/DDLPromiseImageHelper.cpp
+++ b/tools/DDLPromiseImageHelper.cpp
@@ -7,9 +7,9 @@
#include "tools/DDLPromiseImageHelper.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkPicture.h"
#include "include/core/SkSerialProcs.h"
+#include "include/gpu/GrContextThreadSafeProxy.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrYUVABackendTextures.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
diff --git a/tools/DDLPromiseImageHelper.h b/tools/DDLPromiseImageHelper.h
index b023bec..bb7e19f 100644
--- a/tools/DDLPromiseImageHelper.h
+++ b/tools/DDLPromiseImageHelper.h
@@ -9,7 +9,6 @@
#define PromiseImageHelper_DEFINED
#include "include/core/SkBitmap.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkPromiseImageTexture.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkYUVAPixmaps.h"
@@ -18,6 +17,7 @@
#include "src/base/SkTLazy.h"
#include "src/core/SkCachedData.h"
+class GrContextThreadSafeProxy;
class GrDirectContext;
class SkImage;
class SkMipmap;
diff --git a/tools/DDLTileHelper.cpp b/tools/DDLTileHelper.cpp
index 771feff5..10985f0 100644
--- a/tools/DDLTileHelper.cpp
+++ b/tools/DDLTileHelper.cpp
@@ -8,24 +8,25 @@
#include "tools/DDLTileHelper.h"
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayListRecorder.h"
#include "include/core/SkPicture.h"
#include "include/core/SkSurface.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
#include "src/base/SkRandom.h"
-#include "src/core/SkDeferredDisplayListPriv.h"
#include "src/core/SkTaskGroup.h"
#include "src/gpu/ganesh/GrCaps.h"
+#include "src/gpu/ganesh/GrDeferredDisplayListPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
#include "tools/DDLPromiseImageHelper.h"
void DDLTileHelper::TileData::init(int id,
GrDirectContext* direct,
- const SkSurfaceCharacterization& dstSurfaceCharacterization,
+ const GrSurfaceCharacterization& dstSurfaceCharacterization,
const SkIRect& clip,
const SkIRect& paddingOutsets) {
fID = id;
@@ -52,7 +53,7 @@
auto recordingChar = fPlaybackChar.createResized(fClip.width(), fClip.height());
SkASSERT(recordingChar.isValid());
- SkDeferredDisplayListRecorder recorder(recordingChar);
+ GrDeferredDisplayListRecorder recorder(recordingChar);
// DDL TODO: the DDLRecorder's rContext isn't initialized until getCanvas is called.
// Maybe set it up in the ctor?
@@ -72,7 +73,7 @@
void DDLTileHelper::createComposeDDL() {
SkASSERT(!fComposeDDL);
- SkDeferredDisplayListRecorder recorder(fDstCharacterization);
+ GrDeferredDisplayListRecorder recorder(fDstCharacterization);
SkCanvas* recordingCanvas = recorder.getCanvas();
@@ -107,7 +108,7 @@
SkASSERT(fDisplayList);
- SkDeferredDisplayList::ProgramIterator iter(direct, fDisplayList.get());
+ GrDeferredDisplayList::ProgramIterator iter(direct, fDisplayList.get());
for (; !iter.done(); iter.next()) {
iter.compile();
}
@@ -157,7 +158,7 @@
fTileSurface = this->makeWrappedTileDest(direct);
if (fTileSurface) {
- fTileSurface->draw(fDisplayList, this->padOffset().x(), this->padOffset().y());
+ skgpu::ganesh::DrawDDL(fTileSurface, fDisplayList);
// We can't snap an image here bc, since we're using wrapped backend textures for the
// surfaces, that would incur a copy.
@@ -196,7 +197,7 @@
void DDLTileHelper::TileData::CreateBackendTexture(GrDirectContext* direct, TileData* tile) {
SkASSERT(tile->fCallbackContext && !tile->fCallbackContext->promiseImageTexture());
- const SkSurfaceCharacterization& c = tile->fPlaybackChar;
+ const GrSurfaceCharacterization& c = tile->fPlaybackChar;
GrBackendTexture beTex =
direct->createBackendTexture(c.width(),
c.height(),
@@ -229,7 +230,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
DDLTileHelper::DDLTileHelper(GrDirectContext* direct,
- const SkSurfaceCharacterization& dstChar,
+ const GrSurfaceCharacterization& dstChar,
const SkIRect& viewport,
int numXDivisions, int numYDivisions,
bool addRandomPaddingToDst)
diff --git a/tools/DDLTileHelper.h b/tools/DDLTileHelper.h
index 9646d51..42f350a 100644
--- a/tools/DDLTileHelper.h
+++ b/tools/DDLTileHelper.h
@@ -8,22 +8,22 @@
#ifndef DDLTileHelper_DEFINED
#define DDLTileHelper_DEFINED
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSpan.h"
-#include "include/core/SkSurfaceCharacterization.h"
#include "include/private/base/SkTemplates.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
class DDLPromiseImageHelper;
class PromiseImageCallbackContext;
class SkCanvas;
class SkData;
-class SkDeferredDisplayListRecorder;
+class GrDeferredDisplayListRecorder;
class SkImage;
class SkPicture;
class SkSurface;
-class SkSurfaceCharacterization;
+class GrSurfaceCharacterization;
class SkTaskGroup;
class DDLTileHelper {
@@ -39,7 +39,7 @@
void init(int id,
GrDirectContext*,
- const SkSurfaceCharacterization& dstChar,
+ const GrSurfaceCharacterization& dstChar,
const SkIRect& clip,
const SkIRect& paddingOutsets);
@@ -69,7 +69,7 @@
}
SkIVector padOffset() const { return { fPaddingOutsets.fLeft, fPaddingOutsets.fTop }; }
- SkDeferredDisplayList* ddl() { return fDisplayList.get(); }
+ GrDeferredDisplayList* ddl() { return fDisplayList.get(); }
sk_sp<SkImage> makePromiseImageForDst(sk_sp<GrContextThreadSafeProxy>);
void dropCallbackContext() { fCallbackContext.reset(); }
@@ -85,7 +85,7 @@
int fID = -1;
SkIRect fClip; // in the device space of the final SkSurface
SkIRect fPaddingOutsets; // random padding for the output surface
- SkSurfaceCharacterization fPlaybackChar; // characterization for the tile's dst surface
+ GrSurfaceCharacterization fPlaybackChar; // characterization for the tile's dst surface
// The callback context holds (via its SkPromiseImageTexture) the backend texture
// that is both wrapped in 'fTileSurface' and backs this tile's promise image
@@ -97,11 +97,11 @@
// TODO: fix the ref-order so we don't need 'fTileSurface' here
sk_sp<SkSurface> fTileSurface;
- sk_sp<SkDeferredDisplayList> fDisplayList;
+ sk_sp<GrDeferredDisplayList> fDisplayList;
};
DDLTileHelper(GrDirectContext*,
- const SkSurfaceCharacterization& dstChar,
+ const GrSurfaceCharacterization& dstChar,
const SkIRect& viewport,
int numXDivisions, int numYDivisions,
bool addRandomPaddingToDst);
@@ -115,7 +115,7 @@
// Create the DDL that will compose all the tile images into a final result.
void createComposeDDL();
- const sk_sp<SkDeferredDisplayList>& composeDDL() const { return fComposeDDL; }
+ const sk_sp<GrDeferredDisplayList>& composeDDL() const { return fComposeDDL; }
// For each tile, create its DDL and then draw it - all on a single thread. This is to allow
// comparison w/ just drawing the SKP directly (i.e., drawAllTilesDirectly). The
@@ -142,9 +142,9 @@
skia_private::AutoTArray<TileData> fTiles; // 'fNumXDivisions' x
// 'fNumYDivisions'
- sk_sp<SkDeferredDisplayList> fComposeDDL;
+ sk_sp<GrDeferredDisplayList> fComposeDDL;
- const SkSurfaceCharacterization fDstCharacterization;
+ const GrSurfaceCharacterization fDstCharacterization;
};
#endif
diff --git a/tools/skpbench/skpbench.cpp b/tools/skpbench/skpbench.cpp
index ca09d64..dc94640 100644
--- a/tools/skpbench/skpbench.cpp
+++ b/tools/skpbench/skpbench.cpp
@@ -7,7 +7,6 @@
#include "bench/BigPath.h"
#include "include/core/SkCanvas.h"
-#include "include/core/SkDeferredDisplayList.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
@@ -17,6 +16,7 @@
#include "include/effects/SkPerlinNoiseShader.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkTaskGroup.h"
#include "src/gpu/ganesh/GrCaps.h"
@@ -260,7 +260,7 @@
const Sample::duration sampleDuration = std::chrono::milliseconds(FLAGS_sampleMs);
const clock::duration benchDuration = std::chrono::milliseconds(FLAGS_duration);
- SkSurfaceCharacterization dstCharacterization;
+ GrSurfaceCharacterization dstCharacterization;
SkAssertResult(dstSurface->characterize(&dstCharacterization));
SkIRect viewport = dstSurface->imageInfo().bounds();
@@ -327,7 +327,7 @@
if (!FLAGS_png.isEmpty()) {
// The user wants to see the final result
- dstSurface->draw(tiles.composeDDL());
+ skgpu::ganesh::DrawDDL(dstSurface, tiles.composeDDL());
dContext->flushAndSubmit(dstSurface);
}
