diff options
author | Robert Phillips <robertphillips@google.com> | 2016-11-14 13:31:14 -0500 |
---|---|---|
committer | Skia Commit-Bot <skia-commit-bot@chromium.org> | 2016-11-14 19:04:47 +0000 |
commit | 286b96f876953c94c178e3abbeb4eab186ad1fef (patch) | |
tree | 47e473528643cdbe6227d7f1caa915d85a7605a1 /tests | |
parent | f171e1625bd3ea46c2980c97143168598d99987d (diff) |
Add IORef capability to GrSurfaceProxy objects
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4734
Change-Id: If10fbe555e9fa3331bfa01065028e1afe82adb78
Reviewed-on: https://skia-review.googlesource.com/4734
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Diffstat (limited to 'tests')
-rw-r--r-- | tests/ProxyRefTest.cpp | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/tests/ProxyRefTest.cpp b/tests/ProxyRefTest.cpp new file mode 100644 index 0000000000..bbbb02ccde --- /dev/null +++ b/tests/ProxyRefTest.cpp @@ -0,0 +1,200 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +// This is a GPU-backend specific test. + +#include "Test.h" + +#if SK_SUPPORT_GPU +#include "GrSurfaceProxy.h" +#include "GrTextureProxy.h" +#include "GrRenderTargetPriv.h" +#include "GrRenderTargetProxy.h" + +static const int kWidthHeight = 128; + +int32_t GrIORefProxy::getProxyRefCnt_TestOnly() const { + return fRefCnt; +} + +int32_t GrIORefProxy::getBackingRefCnt_TestOnly() const { + if (fTarget) { + return fTarget->fRefCnt; + } + + return fRefCnt; +} + +int32_t GrIORefProxy::getPendingReadCnt_TestOnly() const { + if (fTarget) { + SkASSERT(!fPendingReads); + return fTarget->fPendingReads; + } + + return fPendingReads; +} + +int32_t GrIORefProxy::getPendingWriteCnt_TestOnly() const { + if (fTarget) { + SkASSERT(!fPendingWrites); + return fTarget->fPendingWrites; + } + + return fPendingWrites; +} + +static void check_refs(skiatest::Reporter* reporter, + GrSurfaceProxy* proxy, + int32_t expectedProxyRefs, + int32_t expectedBackingRefs, + int32_t expectedNumReads, + int32_t expectedNumWrites) { + REPORTER_ASSERT(reporter, proxy->getProxyRefCnt_TestOnly() == expectedProxyRefs); + REPORTER_ASSERT(reporter, proxy->getBackingRefCnt_TestOnly() == expectedBackingRefs); + REPORTER_ASSERT(reporter, proxy->getPendingReadCnt_TestOnly() == expectedNumReads); + REPORTER_ASSERT(reporter, proxy->getPendingWriteCnt_TestOnly() == expectedNumWrites); + + SkASSERT(proxy->getProxyRefCnt_TestOnly() == expectedProxyRefs); + SkASSERT(proxy->getBackingRefCnt_TestOnly() == expectedBackingRefs); + SkASSERT(proxy->getPendingReadCnt_TestOnly() == expectedNumReads); + SkASSERT(proxy->getPendingWriteCnt_TestOnly() == expectedNumWrites); +} + +static sk_sp<GrSurfaceProxy> make_deferred(const GrCaps& caps, GrTextureProvider* provider) { + GrSurfaceDesc desc; + desc.fFlags = kRenderTarget_GrSurfaceFlag; + desc.fWidth = kWidthHeight; + desc.fHeight = kWidthHeight; + desc.fConfig = kRGBA_8888_GrPixelConfig; + + return GrSurfaceProxy::MakeDeferred(caps, desc, SkBackingFit::kApprox, SkBudgeted::kYes); +} + +static sk_sp<GrSurfaceProxy> make_wrapped(const GrCaps& caps, GrTextureProvider* provider) { + GrSurfaceDesc desc; + desc.fFlags = kRenderTarget_GrSurfaceFlag; + desc.fWidth = kWidthHeight; + desc.fHeight = kWidthHeight; + desc.fConfig = kRGBA_8888_GrPixelConfig; + + sk_sp<GrTexture> tex(provider->createTexture(desc, SkBudgeted::kNo)); + + // Flush the IOWrite from the initial discard or it will confuse the later ref count checks + tex->flushWrites(); + + return GrSurfaceProxy::MakeWrapped(std::move(tex)); +} + +DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) { + GrTextureProvider* provider = ctxInfo.grContext()->textureProvider(); + const GrCaps& caps = *ctxInfo.grContext()->caps(); + + for (auto make : { make_deferred, make_wrapped }) { + + // A single write + { + sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider)); + + GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(sProxy.get()); + + check_refs(reporter, sProxy.get(), 1, 1, 0, 1); + + // In the deferred case, the discard batch created on instantiation adds an + // extra ref and write + int expectedRefs = !sProxy->isWrapped_ForTesting() ? 2 : 1; + + sProxy->instantiate(provider); + + // In the deferred case, this checks that the refs transfered to the GrSurface + check_refs(reporter, sProxy.get(), 1, expectedRefs, 0, expectedRefs); + } + + // A single read + { + sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider)); + + GrPendingIOResource<GrSurfaceProxy, kRead_GrIOType> fRead(sProxy.get()); + + check_refs(reporter, sProxy.get(), 1, 1, 1, 0); + + // In the deferred case, the discard batch created on instantiation adds an + // extra ref and write + int expectedBackingRefs = !sProxy->isWrapped_ForTesting() ? 2 : 1; + int expectedWrites = !sProxy->isWrapped_ForTesting() ? 1 : 0; + + sProxy->instantiate(provider); + + // In the deferred case, this checks that the refs transfered to the GrSurface + check_refs(reporter, sProxy.get(), 1, expectedBackingRefs, 1, expectedWrites); + } + + // A single read/write pair + { + sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider)); + + GrPendingIOResource<GrSurfaceProxy, kRW_GrIOType> fRW(sProxy.get()); + + check_refs(reporter, sProxy.get(), 1, 1, 1, 1); + + // In the deferred case, the discard batch created on instantiation adds an + // extra ref and write + int expectedBackingRefs = !sProxy->isWrapped_ForTesting() ? 2 : 1; + int expectedWrites = !sProxy->isWrapped_ForTesting() ? 2 : 1; + + sProxy->instantiate(provider); + + // In the deferred case, this checks that the refs transfered to the GrSurface + check_refs(reporter, sProxy.get(), 1, expectedBackingRefs, 1, expectedWrites); + } + + // Multiple normal refs + { + sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider)); + sProxy->ref(); + sProxy->ref(); + + check_refs(reporter, sProxy.get(), 3, 3, 0, 0); + + int expectedBackingRefs = !sProxy->isWrapped_ForTesting() ? 4 : 3; + int expectedWrites = !sProxy->isWrapped_ForTesting() ? 1 : 0; + + sProxy->instantiate(provider); + + // In the deferred case, this checks that the refs transfered to the GrSurface + check_refs(reporter, sProxy.get(), 3, expectedBackingRefs, 0, expectedWrites); + + sProxy->unref(); + sProxy->unref(); + } + + // Continue using (reffing) proxy after instantiation + { + sk_sp<GrSurfaceProxy> sProxy((*make)(caps, provider)); + sProxy->ref(); + + GrPendingIOResource<GrSurfaceProxy, kWrite_GrIOType> fWrite(sProxy.get()); + + check_refs(reporter, sProxy.get(), 2, 2, 0, 1); + + int expectedBackingRefs = !sProxy->isWrapped_ForTesting() ? 3 : 2; + int expectedWrites = !sProxy->isWrapped_ForTesting() ? 2 : 1; + + sProxy->instantiate(provider); + + // In the deferred case, this checks that the refs transfered to the GrSurface + check_refs(reporter, sProxy.get(), 2, expectedBackingRefs, 0, expectedWrites); + + sProxy->unref(); + check_refs(reporter, sProxy.get(), 1, expectedBackingRefs-1, 0, expectedWrites); + + GrPendingIOResource<GrSurfaceProxy, kRead_GrIOType> fRead(sProxy.get()); + check_refs(reporter, sProxy.get(), 1, expectedBackingRefs-1, 1, expectedWrites); + } + } +} + +#endif |