commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "GrTest.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 9 | #include <algorithm> |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 10 | #include "GrBackendSurface.h" |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 11 | #include "GrContextOptions.h" |
Chris Dalton | fe199b7 | 2017-05-05 11:26:15 -0400 | [diff] [blame] | 12 | #include "GrContextPriv.h" |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 13 | #include "GrDrawOpAtlas.h" |
robertphillips | 77a2e52 | 2015-10-17 07:43:27 -0700 | [diff] [blame] | 14 | #include "GrDrawingManager.h" |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 15 | #include "GrGpu.h" |
bsalomon | 3582d3e | 2015-02-13 14:20:05 -0800 | [diff] [blame] | 16 | #include "GrGpuResourceCacheAccess.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 17 | #include "GrRenderTargetContext.h" |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 18 | #include "GrRenderTargetContextPriv.h" |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 19 | #include "GrRenderTargetProxy.h" |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 20 | #include "GrResourceCache.h" |
Greg Daniel | 6be3523 | 2017-03-01 17:01:09 -0500 | [diff] [blame] | 21 | #include "GrSemaphore.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 22 | #include "GrSurfaceContextPriv.h" |
Robert Phillips | 646e429 | 2017-06-13 12:44:56 -0400 | [diff] [blame] | 23 | #include "GrTexture.h" |
Brian Osman | 3b65598 | 2017-03-07 16:58:08 -0500 | [diff] [blame] | 24 | #include "SkGr.h" |
Robert Phillips | 22f4a1f | 2016-12-20 08:57:26 -0500 | [diff] [blame] | 25 | #include "SkImage_Gpu.h" |
halcanary | 4dbbd04 | 2016-06-07 17:21:10 -0700 | [diff] [blame] | 26 | #include "SkMathPriv.h" |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 27 | #include "SkString.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 28 | #include "ops/GrMeshDrawOp.h" |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 29 | #include "text/GrAtlasGlyphCache.h" |
joshualitt | e804292 | 2015-12-11 06:11:21 -0800 | [diff] [blame] | 30 | #include "text/GrTextBlobCache.h" |
| 31 | |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 32 | namespace GrTest { |
Brian Salomon | d17f658 | 2017-07-19 18:28:58 -0400 | [diff] [blame] | 33 | |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 34 | void SetupAlwaysEvictAtlas(GrContext* context) { |
| 35 | // These sizes were selected because they allow each atlas to hold a single plot and will thus |
| 36 | // stress the atlas |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 37 | int dim = GrDrawOpAtlas::kGlyphMaxDim; |
| 38 | GrDrawOpAtlasConfig configs[3]; |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 39 | configs[kA8_GrMaskFormat].fWidth = dim; |
| 40 | configs[kA8_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 41 | configs[kA8_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 42 | configs[kA8_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 43 | configs[kA8_GrMaskFormat].fPlotWidth = dim; |
| 44 | configs[kA8_GrMaskFormat].fPlotHeight = dim; |
| 45 | |
| 46 | configs[kA565_GrMaskFormat].fWidth = dim; |
| 47 | configs[kA565_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 48 | configs[kA565_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 49 | configs[kA565_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 50 | configs[kA565_GrMaskFormat].fPlotWidth = dim; |
| 51 | configs[kA565_GrMaskFormat].fPlotHeight = dim; |
| 52 | |
| 53 | configs[kARGB_GrMaskFormat].fWidth = dim; |
| 54 | configs[kARGB_GrMaskFormat].fHeight = dim; |
jvanverth | 7023a00 | 2016-02-22 11:25:32 -0800 | [diff] [blame] | 55 | configs[kARGB_GrMaskFormat].fLog2Width = SkNextLog2(dim); |
| 56 | configs[kARGB_GrMaskFormat].fLog2Height = SkNextLog2(dim); |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 57 | configs[kARGB_GrMaskFormat].fPlotWidth = dim; |
| 58 | configs[kARGB_GrMaskFormat].fPlotHeight = dim; |
| 59 | |
| 60 | context->setTextContextAtlasSizes_ForTesting(configs); |
| 61 | } |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 62 | |
| 63 | GrBackendTexture CreateBackendTexture(GrBackend backend, int width, int height, |
| 64 | GrPixelConfig config, GrBackendObject handle) { |
Brian Salomon | d17f658 | 2017-07-19 18:28:58 -0400 | [diff] [blame] | 65 | switch (backend) { |
Mike Reed | d20b5c4 | 2017-06-14 06:03:10 -0400 | [diff] [blame] | 66 | #ifdef SK_VULKAN |
Brian Salomon | d17f658 | 2017-07-19 18:28:58 -0400 | [diff] [blame] | 67 | case kVulkan_GrBackend: { |
| 68 | GrVkImageInfo* vkInfo = (GrVkImageInfo*)(handle); |
| 69 | return GrBackendTexture(width, height, *vkInfo); |
| 70 | } |
Robert Phillips | fcd5fdd | 2017-06-14 01:43:29 +0000 | [diff] [blame] | 71 | #endif |
Brian Salomon | d17f658 | 2017-07-19 18:28:58 -0400 | [diff] [blame] | 72 | case kOpenGL_GrBackend: { |
| 73 | GrGLTextureInfo* glInfo = (GrGLTextureInfo*)(handle); |
| 74 | return GrBackendTexture(width, height, config, *glInfo); |
| 75 | } |
| 76 | case kMock_GrBackend: { |
| 77 | GrMockTextureInfo* mockInfo = (GrMockTextureInfo*)(handle); |
| 78 | return GrBackendTexture(width, height, config, *mockInfo); |
| 79 | } |
| 80 | default: |
| 81 | return GrBackendTexture(); |
| 82 | } |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 83 | } |
Brian Salomon | d17f658 | 2017-07-19 18:28:58 -0400 | [diff] [blame] | 84 | |
| 85 | } // namespace GrTest |
joshualitt | 7f9c9eb | 2015-08-21 11:08:00 -0700 | [diff] [blame] | 86 | |
Robert Phillips | eaa8625 | 2016-11-08 13:49:39 +0000 | [diff] [blame] | 87 | bool GrSurfaceProxy::isWrapped_ForTesting() const { |
| 88 | return SkToBool(fTarget); |
| 89 | } |
| 90 | |
| 91 | bool GrRenderTargetContext::isWrapped_ForTesting() const { |
| 92 | return fRenderTargetProxy->isWrapped_ForTesting(); |
| 93 | } |
| 94 | |
joshualitt | 17d833b | 2015-08-03 10:17:44 -0700 | [diff] [blame] | 95 | void GrContext::setTextBlobCacheLimit_ForTesting(size_t bytes) { |
| 96 | fTextBlobCache->setBudget(bytes); |
| 97 | } |
| 98 | |
Brian Salomon | 2ee084e | 2016-12-16 18:59:19 -0500 | [diff] [blame] | 99 | void GrContext::setTextContextAtlasSizes_ForTesting(const GrDrawOpAtlasConfig* configs) { |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 100 | fAtlasGlyphCache->setAtlasSizes_ForTesting(configs); |
joshualitt | da04e0e | 2015-08-19 08:16:43 -0700 | [diff] [blame] | 101 | } |
| 102 | |
commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 103 | /////////////////////////////////////////////////////////////////////////////// |
| 104 | |
robertphillips@google.com | 94d8f1e | 2013-12-18 17:25:33 +0000 | [diff] [blame] | 105 | void GrContext::purgeAllUnlockedResources() { |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 106 | fResourceCache->purgeAllUnlocked(); |
robertphillips@google.com | 94d8f1e | 2013-12-18 17:25:33 +0000 | [diff] [blame] | 107 | } |
bsalomon | 3343557 | 2014-11-05 14:47:41 -0800 | [diff] [blame] | 108 | |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 109 | void GrContext::resetGpuStats() const { |
| 110 | #if GR_GPU_STATS |
| 111 | fGpu->stats()->reset(); |
| 112 | #endif |
| 113 | } |
| 114 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 115 | void GrContext::dumpCacheStats(SkString* out) const { |
| 116 | #if GR_CACHE_STATS |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 117 | fResourceCache->dumpStats(out); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 118 | #endif |
| 119 | } |
| 120 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 121 | void GrContext::dumpCacheStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 122 | SkTArray<double>* values) const { |
| 123 | #if GR_CACHE_STATS |
| 124 | fResourceCache->dumpStatsKeyValuePairs(keys, values); |
| 125 | #endif |
| 126 | } |
| 127 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 128 | void GrContext::printCacheStats() const { |
| 129 | SkString out; |
| 130 | this->dumpCacheStats(&out); |
kkinnunen | 297aaf9 | 2015-02-19 06:32:12 -0800 | [diff] [blame] | 131 | SkDebugf("%s", out.c_str()); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 132 | } |
| 133 | |
| 134 | void GrContext::dumpGpuStats(SkString* out) const { |
| 135 | #if GR_GPU_STATS |
| 136 | return fGpu->stats()->dump(out); |
| 137 | #endif |
| 138 | } |
| 139 | |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 140 | void GrContext::dumpGpuStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 141 | SkTArray<double>* values) const { |
| 142 | #if GR_GPU_STATS |
| 143 | return fGpu->stats()->dumpKeyValuePairs(keys, values); |
| 144 | #endif |
| 145 | } |
| 146 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 147 | void GrContext::printGpuStats() const { |
| 148 | SkString out; |
| 149 | this->dumpGpuStats(&out); |
kkinnunen | 297aaf9 | 2015-02-19 06:32:12 -0800 | [diff] [blame] | 150 | SkDebugf("%s", out.c_str()); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 151 | } |
| 152 | |
Robert Phillips | c37e614 | 2017-01-20 10:03:25 -0500 | [diff] [blame] | 153 | sk_sp<SkImage> GrContext::getFontAtlasImage_ForTesting(GrMaskFormat format) { |
Brian Salomon | f856fd1 | 2016-12-16 14:24:34 -0500 | [diff] [blame] | 154 | GrAtlasGlyphCache* cache = this->getAtlasGlyphCache(); |
jvanverth | 629162d | 2015-11-08 08:07:24 -0800 | [diff] [blame] | 155 | |
Robert Phillips | 32f2818 | 2017-02-28 16:20:03 -0500 | [diff] [blame] | 156 | sk_sp<GrTextureProxy> proxy = cache->getProxy(format); |
| 157 | if (!proxy) { |
| 158 | return nullptr; |
| 159 | } |
| 160 | |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 161 | SkASSERT(proxy->priv().isExact()); |
| 162 | sk_sp<SkImage> image(new SkImage_Gpu(this, kNeedNewImageUniqueID, kPremul_SkAlphaType, |
| 163 | std::move(proxy), nullptr, SkBudgeted::kNo)); |
Robert Phillips | 22f4a1f | 2016-12-20 08:57:26 -0500 | [diff] [blame] | 164 | return image; |
jvanverth | 0671b96 | 2015-12-08 18:53:44 -0800 | [diff] [blame] | 165 | } |
jvanverth | 629162d | 2015-11-08 08:07:24 -0800 | [diff] [blame] | 166 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 167 | #if GR_GPU_STATS |
| 168 | void GrGpu::Stats::dump(SkString* out) { |
| 169 | out->appendf("Render Target Binds: %d\n", fRenderTargetBinds); |
| 170 | out->appendf("Shader Compilations: %d\n", fShaderCompilations); |
bsalomon | b12ea41 | 2015-02-02 21:19:50 -0800 | [diff] [blame] | 171 | out->appendf("Textures Created: %d\n", fTextureCreates); |
| 172 | out->appendf("Texture Uploads: %d\n", fTextureUploads); |
jvanverth | 17aa047 | 2016-01-05 10:41:27 -0800 | [diff] [blame] | 173 | out->appendf("Transfers to Texture: %d\n", fTransfersToTexture); |
egdaniel | 8dc7c3a | 2015-04-16 11:22:42 -0700 | [diff] [blame] | 174 | out->appendf("Stencil Buffer Creates: %d\n", fStencilAttachmentCreates); |
joshualitt | 87a5c9f | 2015-09-08 13:42:05 -0700 | [diff] [blame] | 175 | out->appendf("Number of draws: %d\n", fNumDraws); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 176 | } |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 177 | |
| 178 | void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) { |
| 179 | keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds); |
| 180 | keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 181 | keys->push_back(SkString("texture_uploads")); values->push_back(fTextureUploads); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 182 | keys->push_back(SkString("number_of_draws")); values->push_back(fNumDraws); |
bsalomon | 1d417a8 | 2016-03-23 11:50:26 -0700 | [diff] [blame] | 183 | keys->push_back(SkString("number_of_failed_draws")); values->push_back(fNumFailedDraws); |
joshualitt | e45c81c | 2015-12-02 09:05:37 -0800 | [diff] [blame] | 184 | } |
| 185 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 186 | #endif |
| 187 | |
| 188 | #if GR_CACHE_STATS |
robertphillips | 60029a5 | 2015-11-09 13:51:06 -0800 | [diff] [blame] | 189 | void GrResourceCache::getStats(Stats* stats) const { |
| 190 | stats->reset(); |
| 191 | |
| 192 | stats->fTotal = this->getResourceCount(); |
| 193 | stats->fNumNonPurgeable = fNonpurgeableResources.count(); |
| 194 | stats->fNumPurgeable = fPurgeableQueue.count(); |
| 195 | |
| 196 | for (int i = 0; i < fNonpurgeableResources.count(); ++i) { |
| 197 | stats->update(fNonpurgeableResources[i]); |
| 198 | } |
| 199 | for (int i = 0; i < fPurgeableQueue.count(); ++i) { |
| 200 | stats->update(fPurgeableQueue.at(i)); |
| 201 | } |
| 202 | } |
| 203 | |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 204 | void GrResourceCache::dumpStats(SkString* out) const { |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 205 | this->validate(); |
| 206 | |
bsalomon | f320e04 | 2015-02-17 15:09:34 -0800 | [diff] [blame] | 207 | Stats stats; |
| 208 | |
robertphillips | 60029a5 | 2015-11-09 13:51:06 -0800 | [diff] [blame] | 209 | this->getStats(&stats); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 210 | |
| 211 | float countUtilization = (100.f * fBudgetedCount) / fMaxCount; |
| 212 | float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes; |
| 213 | |
| 214 | out->appendf("Budget: %d items %d bytes\n", fMaxCount, (int)fMaxBytes); |
| 215 | out->appendf("\t\tEntry Count: current %d" |
kkinnunen | 2e6055b | 2016-04-22 01:48:29 -0700 | [diff] [blame] | 216 | " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n", |
| 217 | stats.fTotal, fBudgetedCount, stats.fWrapped, stats.fNumNonPurgeable, |
| 218 | stats.fScratch, countUtilization, fHighWaterCount); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 219 | out->appendf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n", |
bsalomon | f320e04 | 2015-02-17 15:09:34 -0800 | [diff] [blame] | 220 | SkToInt(fBytes), SkToInt(fBudgetedBytes), byteUtilization, |
| 221 | SkToInt(stats.fUnbudgetedSize), SkToInt(fHighWaterBytes)); |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 222 | } |
| 223 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 224 | void GrResourceCache::dumpStatsKeyValuePairs(SkTArray<SkString>* keys, |
| 225 | SkTArray<double>* values) const { |
| 226 | this->validate(); |
| 227 | |
| 228 | Stats stats; |
| 229 | this->getStats(&stats); |
| 230 | |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 231 | keys->push_back(SkString("gpu_cache_purgable_entries")); values->push_back(stats.fNumPurgeable); |
joshualitt | dc5685a | 2015-12-02 14:08:25 -0800 | [diff] [blame] | 232 | } |
| 233 | |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 234 | #endif |
| 235 | |
bsalomon | ddf30e6 | 2015-02-19 11:38:44 -0800 | [diff] [blame] | 236 | /////////////////////////////////////////////////////////////////////////////// |
| 237 | |
| 238 | void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newTimestamp; } |
mtklein | b9eb4ac | 2015-02-02 18:26:03 -0800 | [diff] [blame] | 239 | |
Brian Salomon | 1090da6 | 2017-01-06 12:04:19 -0500 | [diff] [blame] | 240 | #ifdef SK_DEBUG |
| 241 | int GrResourceCache::countUniqueKeysWithTag(const char* tag) const { |
| 242 | int count = 0; |
| 243 | UniqueHash::ConstIter iter(&fUniqueHash); |
| 244 | while (!iter.done()) { |
| 245 | if (0 == strcmp(tag, (*iter).getUniqueKey().tag())) { |
| 246 | ++count; |
| 247 | } |
| 248 | ++iter; |
| 249 | } |
| 250 | return count; |
| 251 | } |
| 252 | #endif |
| 253 | |
bsalomon | 3343557 | 2014-11-05 14:47:41 -0800 | [diff] [blame] | 254 | /////////////////////////////////////////////////////////////////////////////// |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 255 | |
| 256 | #define ASSERT_SINGLE_OWNER \ |
Robert Phillips | a90aa2b | 2017-04-10 08:19:26 -0400 | [diff] [blame] | 257 | SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fRenderTargetContext->singleOwner());) |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 258 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 259 | uint32_t GrRenderTargetContextPriv::testingOnly_addDrawOp(std::unique_ptr<GrDrawOp> op) { |
| 260 | ASSERT_SINGLE_OWNER |
| 261 | if (fRenderTargetContext->drawingManager()->wasAbandoned()) { |
| 262 | return SK_InvalidUniqueID; |
| 263 | } |
| 264 | SkDEBUGCODE(fRenderTargetContext->validate()); |
| 265 | GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, |
| 266 | "GrRenderTargetContext::testingOnly_addDrawOp"); |
| 267 | return fRenderTargetContext->addDrawOp(GrNoClip(), std::move(op)); |
| 268 | } |
| 269 | |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 270 | #undef ASSERT_SINGLE_OWNER |
joshualitt | f5883a6 | 2016-01-13 07:47:38 -0800 | [diff] [blame] | 271 | |
| 272 | /////////////////////////////////////////////////////////////////////////////// |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 273 | |
Robert Phillips | c4f0a82 | 2017-06-13 08:11:36 -0400 | [diff] [blame] | 274 | GrRenderTargetFlags GrRenderTargetProxy::testingOnly_getFlags() const { |
Brian Salomon | dac5f6b | 2017-02-28 16:11:04 -0500 | [diff] [blame] | 275 | return fRenderTargetFlags; |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 276 | } |
| 277 | |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 278 | ////////////////////////////////////////////////////////////////////////////// |
| 279 | |
Chris Dalton | fe199b7 | 2017-05-05 11:26:15 -0400 | [diff] [blame] | 280 | void GrContextPriv::testingOnly_flushAndRemoveOnFlushCallbackObject(GrOnFlushCallbackObject* cb) { |
| 281 | fContext->flush(); |
| 282 | fContext->fDrawingManager->testingOnly_removeOnFlushCallbackObject(cb); |
| 283 | } |
| 284 | |
| 285 | void GrDrawingManager::testingOnly_removeOnFlushCallbackObject(GrOnFlushCallbackObject* cb) { |
| 286 | int n = std::find(fOnFlushCBObjects.begin(), fOnFlushCBObjects.end(), cb) - |
| 287 | fOnFlushCBObjects.begin(); |
| 288 | SkASSERT(n < fOnFlushCBObjects.count()); |
| 289 | fOnFlushCBObjects.removeShuffle(n); |
| 290 | } |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 291 | |
| 292 | ////////////////////////////////////////////////////////////////////////////// |
| 293 | |
| 294 | #define DRAW_OP_TEST_EXTERN(Op) \ |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 295 | extern std::unique_ptr<GrDrawOp> Op##__Test(GrPaint&&, SkRandom*, GrContext*, GrFSAAType) |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 296 | #define DRAW_OP_TEST_ENTRY(Op) Op##__Test |
| 297 | |
Brian Salomon | 10978a6 | 2017-06-15 16:21:49 -0400 | [diff] [blame] | 298 | DRAW_OP_TEST_EXTERN(AAConvexPathOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 299 | DRAW_OP_TEST_EXTERN(AAFillRectOp); |
Brian Salomon | b295573 | 2017-07-13 16:42:55 -0400 | [diff] [blame] | 300 | DRAW_OP_TEST_EXTERN(AAFlatteningConvexPathOp); |
Brian Salomon | a531f25 | 2017-07-07 13:29:28 -0400 | [diff] [blame] | 301 | DRAW_OP_TEST_EXTERN(AAHairlineOp); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 302 | DRAW_OP_TEST_EXTERN(AAStrokeRectOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 303 | DRAW_OP_TEST_EXTERN(CircleOp); |
Brian Salomon | 98222ac | 2017-07-12 15:27:54 -0400 | [diff] [blame] | 304 | DRAW_OP_TEST_EXTERN(DashOp); |
Brian Salomon | ee3e0ba | 2017-07-13 16:40:46 -0400 | [diff] [blame] | 305 | DRAW_OP_TEST_EXTERN(DefaultPathOp); |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 306 | DRAW_OP_TEST_EXTERN(DIEllipseOp); |
| 307 | DRAW_OP_TEST_EXTERN(EllipseOp); |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 308 | DRAW_OP_TEST_EXTERN(GrAtlasTextOp); |
Brian Salomon | 0088f94 | 2017-07-12 11:51:27 -0400 | [diff] [blame] | 309 | DRAW_OP_TEST_EXTERN(GrDrawAtlasOp); |
Brian Salomon | c2f4254 | 2017-07-12 14:11:22 -0400 | [diff] [blame] | 310 | DRAW_OP_TEST_EXTERN(GrDrawVerticesOp); |
Brian Salomon | 815486c | 2017-07-11 08:52:13 -0400 | [diff] [blame] | 311 | DRAW_OP_TEST_EXTERN(NonAAFillRectOp); |
| 312 | DRAW_OP_TEST_EXTERN(NonAALatticeOp); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 313 | DRAW_OP_TEST_EXTERN(NonAAStrokeRectOp); |
Brian Salomon | 0596909 | 2017-07-13 11:20:51 -0400 | [diff] [blame] | 314 | DRAW_OP_TEST_EXTERN(ShadowRRectOp); |
Brian Salomon | febbd23 | 2017-07-11 15:52:02 -0400 | [diff] [blame] | 315 | DRAW_OP_TEST_EXTERN(SmallPathOp); |
Brian Salomon | f036632 | 2017-07-11 15:53:05 -0400 | [diff] [blame] | 316 | DRAW_OP_TEST_EXTERN(RegionOp); |
Brian Salomon | 05441c4 | 2017-05-15 16:45:49 -0400 | [diff] [blame] | 317 | DRAW_OP_TEST_EXTERN(RRectOp); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 318 | DRAW_OP_TEST_EXTERN(TesselatingPathOp); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame^] | 319 | DRAW_OP_TEST_EXTERN(TextureOp); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 320 | |
| 321 | void GrDrawRandomOp(SkRandom* random, GrRenderTargetContext* renderTargetContext, GrPaint&& paint) { |
| 322 | GrContext* context = renderTargetContext->surfPriv().getContext(); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 323 | using MakeDrawOpFn = std::unique_ptr<GrDrawOp>(GrPaint&&, SkRandom*, GrContext*, GrFSAAType); |
| 324 | static constexpr MakeDrawOpFn* gFactories[] = { |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame^] | 325 | DRAW_OP_TEST_ENTRY(AAConvexPathOp), |
| 326 | DRAW_OP_TEST_ENTRY(AAFillRectOp), |
| 327 | DRAW_OP_TEST_ENTRY(AAFlatteningConvexPathOp), |
| 328 | DRAW_OP_TEST_ENTRY(AAHairlineOp), |
| 329 | DRAW_OP_TEST_ENTRY(AAStrokeRectOp), |
| 330 | DRAW_OP_TEST_ENTRY(CircleOp), |
| 331 | DRAW_OP_TEST_ENTRY(DashOp), |
| 332 | DRAW_OP_TEST_ENTRY(DefaultPathOp), |
| 333 | DRAW_OP_TEST_ENTRY(DIEllipseOp), |
| 334 | DRAW_OP_TEST_ENTRY(EllipseOp), |
| 335 | DRAW_OP_TEST_ENTRY(GrAtlasTextOp), |
| 336 | DRAW_OP_TEST_ENTRY(GrDrawAtlasOp), |
| 337 | DRAW_OP_TEST_ENTRY(GrDrawVerticesOp), |
| 338 | DRAW_OP_TEST_ENTRY(NonAAFillRectOp), |
| 339 | DRAW_OP_TEST_ENTRY(NonAALatticeOp), |
| 340 | DRAW_OP_TEST_ENTRY(NonAAStrokeRectOp), |
| 341 | DRAW_OP_TEST_ENTRY(ShadowRRectOp), |
| 342 | DRAW_OP_TEST_ENTRY(SmallPathOp), |
| 343 | DRAW_OP_TEST_ENTRY(RegionOp), |
| 344 | DRAW_OP_TEST_ENTRY(RRectOp), |
| 345 | DRAW_OP_TEST_ENTRY(TesselatingPathOp), |
| 346 | DRAW_OP_TEST_ENTRY(TextureOp), |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 347 | }; |
| 348 | |
Brian Salomon | fc26f3c | 2017-07-14 15:27:56 -0400 | [diff] [blame] | 349 | static constexpr size_t kTotal = SK_ARRAY_COUNT(gFactories); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 350 | uint32_t index = random->nextULessThan(static_cast<uint32_t>(kTotal)); |
Brian Salomon | fc26f3c | 2017-07-14 15:27:56 -0400 | [diff] [blame] | 351 | auto op = gFactories[index]( |
| 352 | std::move(paint), random, context, renderTargetContext->fsaaType()); |
| 353 | SkASSERT(op); |
| 354 | renderTargetContext->priv().testingOnly_addDrawOp(std::move(op)); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 355 | } |