blob: 95c0c62e7c4da5fa30218cf0d8c3f38a08891362 [file] [log] [blame]
bsalomon@google.com27847de2011-02-22 20:59:41 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2011 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.
bsalomon@google.com27847de2011-02-22 20:59:41 +00006 */
7
bsalomon@google.com1fadb202011-12-12 16:10:08 +00008#include "GrContext.h"
Brian Salomon5f33a8c2018-02-26 14:32:39 -05009#include "GrBackendSemaphore.h"
robertphillips77a2e522015-10-17 07:43:27 -070010#include "GrDrawingManager.h"
Robert Phillips646e4292017-06-13 12:44:56 -040011#include "GrGpu.h"
Robert Phillipsc994a932018-06-19 13:09:54 -040012#include "GrMemoryPool.h"
Robert Phillipsdbaf3172019-02-06 15:12:53 -050013#include "GrPathRendererChain.h"
Robert Phillips1afd4cd2018-01-08 13:40:32 -050014#include "GrProxyProvider.h"
Brian Salomonc65aec92017-03-09 09:03:58 -050015#include "GrRenderTargetProxy.h"
bsalomon0ea80f42015-02-11 10:49:59 -080016#include "GrResourceCache.h"
bsalomond309e7a2015-04-30 14:18:54 -070017#include "GrResourceProvider.h"
Greg Danield85f97d2017-03-07 13:37:21 -050018#include "GrSemaphore.h"
robertphillips@google.com72176b22012-05-23 13:19:12 +000019#include "GrSoftwarePathRenderer.h"
Brian Salomondcbb9d92017-07-19 10:53:20 -040020#include "GrTracing.h"
Robert Phillipsd5f9cdd2018-01-31 09:29:48 -050021#include "SkDeferredDisplayList.h"
Brian Osman3b655982017-03-07 16:58:08 -050022#include "SkGr.h"
Mike Reed7fcfb622018-02-09 13:26:46 -050023#include "SkImageInfoPriv.h"
Brian Osman51279982017-08-23 10:12:00 -040024#include "SkMakeUnique.h"
Robert Phillips6b6fcc72018-03-30 13:57:00 -040025#include "SkSurface_Gpu.h"
Brian Osman51279982017-08-23 10:12:00 -040026#include "SkTaskGroup.h"
Khushal71652e22018-10-29 13:05:36 -070027#include "SkTraceMemoryDump.h"
joshualitt5478d422014-11-14 16:00:38 -080028#include "effects/GrConfigConversionEffect.h"
Ethan Nicholas00543112018-07-31 09:44:36 -040029#include "effects/GrSkSLFP.h"
Chris Dalton6c3879d2018-11-01 11:13:19 -060030#include "ccpr/GrCoverageCountingPathRenderer.h"
Brian Salomon5f33a8c2018-02-26 14:32:39 -050031#include "text/GrTextBlobCache.h"
Robert Phillipsdbaf3172019-02-06 15:12:53 -050032#include "text/GrTextContext.h"
Mike Klein0ec1c572018-12-04 11:52:51 -050033#include <atomic>
34#include <unordered_map>
Greg Danielb76a72a2017-07-13 15:07:54 -040035
Robert Phillipse78b7252017-04-06 07:59:41 -040036#define ASSERT_OWNED_PROXY(P) \
Brian Salomonfd98c2c2018-07-31 17:25:29 -040037 SkASSERT(!(P) || !((P)->peekTexture()) || (P)->peekTexture()->getContext() == this)
Robert Phillips7ee385e2017-03-30 08:02:11 -040038
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +000039#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this)
joshualitt1de610a2016-01-06 08:26:09 -080040#define ASSERT_SINGLE_OWNER \
Robert Phillipsa41c6852019-02-07 10:44:10 -050041 SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(this->singleOwner());)
Robert Phillipsa9162df2019-02-11 14:12:03 -050042#define RETURN_IF_ABANDONED if (this->abandoned()) { return; }
43#define RETURN_FALSE_IF_ABANDONED if (this->abandoned()) { return false; }
44#define RETURN_NULL_IF_ABANDONED if (this->abandoned()) { return nullptr; }
bsalomon@google.combc4b6542011-11-19 13:56:11 +000045
robertphillipsea461502015-05-26 11:38:03 -070046////////////////////////////////////////////////////////////////////////////////
47
Robert Phillipsa41c6852019-02-07 10:44:10 -050048GrContext::GrContext(GrBackendApi backend, const GrContextOptions& options, int32_t contextID)
49 : INHERITED(backend, options, contextID) {
halcanary96fcdcc2015-08-27 07:41:13 -070050 fResourceCache = nullptr;
51 fResourceProvider = nullptr;
bsalomon@google.com6e4e6502013-02-25 20:12:45 +000052}
53
Robert Phillips292a6b22019-02-14 14:49:02 -050054GrContext::~GrContext() {
55 ASSERT_SINGLE_OWNER
56
Robert Phillips6a6de562019-02-15 15:19:15 -050057 if (this->drawingManager()) {
58 this->drawingManager()->cleanup();
Robert Phillips292a6b22019-02-14 14:49:02 -050059 }
60 delete fResourceProvider;
61 delete fResourceCache;
Robert Phillips292a6b22019-02-14 14:49:02 -050062}
63
Robert Phillipsbb606772019-02-04 17:50:57 -050064bool GrContext::init(sk_sp<const GrCaps> caps, sk_sp<GrSkSLFPFactoryCache> FPFactoryCache) {
Greg Danielb76a72a2017-07-13 15:07:54 -040065 ASSERT_SINGLE_OWNER
Robert Phillipsfde6fa02018-03-02 08:53:14 -050066 SkASSERT(fThreadSafeProxy); // needs to have been initialized by derived classes
Robert Phillipsa41c6852019-02-07 10:44:10 -050067 SkASSERT(this->proxyProvider());
Robert Phillips88260b52018-01-19 12:56:09 -050068
Robert Phillipsbb606772019-02-04 17:50:57 -050069 if (!INHERITED::init(std::move(caps), std::move(FPFactoryCache))) {
70 return false;
71 }
72
73 SkASSERT(this->caps());
Robert Phillips2184fb72019-02-21 16:11:41 -050074 SkASSERT(this->getGlyphCache());
75 SkASSERT(this->getTextBlobCache());
Robert Phillipsbb606772019-02-04 17:50:57 -050076
Robert Phillips88260b52018-01-19 12:56:09 -050077 if (fGpu) {
Robert Phillipsa41c6852019-02-07 10:44:10 -050078 fResourceCache = new GrResourceCache(this->caps(), this->singleOwner(), this->contextID());
79 fResourceProvider = new GrResourceProvider(fGpu.get(), fResourceCache, this->singleOwner(),
Robert Phillips292a6b22019-02-14 14:49:02 -050080 this->explicitlyAllocateGPUResources());
Robert Phillips88260b52018-01-19 12:56:09 -050081 }
82
Robert Phillips88260b52018-01-19 12:56:09 -050083 if (fResourceCache) {
Robert Phillipsa41c6852019-02-07 10:44:10 -050084 fResourceCache->setProxyProvider(this->proxyProvider());
Robert Phillips88260b52018-01-19 12:56:09 -050085 }
Robert Phillips1afd4cd2018-01-08 13:40:32 -050086
bsalomon@google.com6e4e6502013-02-25 20:12:45 +000087 fDidTestPMConversions = false;
88
bsalomon6b2552f2016-09-15 13:50:26 -070089 GrPathRendererChain::Options prcOptions;
Robert Phillipsc1541ae2019-02-04 12:05:37 -050090 prcOptions.fAllowPathMaskCaching = this->options().fAllowPathMaskCaching;
Brian Osman195c05b2017-08-30 15:14:04 -040091#if GR_TEST_UTILS
Robert Phillipsc1541ae2019-02-04 12:05:37 -050092 prcOptions.fGpuPathRenderers = this->options().fGpuPathRenderers;
Brian Osman195c05b2017-08-30 15:14:04 -040093#endif
Robert Phillipsc1541ae2019-02-04 12:05:37 -050094 if (this->options().fDisableCoverageCountingPaths) {
Chris Daltonef125092018-06-26 18:16:47 -060095 prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kCoverageCounting;
96 }
Robert Phillipsc1541ae2019-02-04 12:05:37 -050097 if (this->options().fDisableDistanceFieldPaths) {
Brian Osman195c05b2017-08-30 15:14:04 -040098 prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
Brian Osmanb350ae22017-08-29 16:15:39 -040099 }
Brian Salomonaf597482017-11-07 16:23:34 -0500100
Robert Phillipsd5f9cdd2018-01-31 09:29:48 -0500101 if (!fResourceCache) {
102 // DDL TODO: remove this crippling of the path renderer chain
103 // Disable the small path renderer bc of the proxies in the atlas. They need to be
104 // unified when the opLists are added back to the destination drawing manager.
105 prcOptions.fGpuPathRenderers &= ~GpuPathRenderers::kSmall;
106 }
107
Herb Derby26cbe512018-05-24 14:39:01 -0400108 GrTextContext::Options textContextOptions;
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500109 textContextOptions.fMaxDistanceFieldFontSize = this->options().fGlyphsAsPathsFontSize;
110 textContextOptions.fMinDistanceFieldFontSize = this->options().fMinDistanceFieldFontSize;
Herb Derby26cbe512018-05-24 14:39:01 -0400111 textContextOptions.fDistanceFieldVerticesAlwaysHaveW = false;
Brian Salomonb5086962017-12-13 10:59:33 -0500112#if SK_SUPPORT_ATLAS_TEXT
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500113 if (GrContextOptions::Enable::kYes == this->options().fDistanceFieldGlyphVerticesAlwaysHaveW) {
Herb Derby26cbe512018-05-24 14:39:01 -0400114 textContextOptions.fDistanceFieldVerticesAlwaysHaveW = true;
Brian Salomonb5086962017-12-13 10:59:33 -0500115 }
116#endif
Brian Salomonaf597482017-11-07 16:23:34 -0500117
Herb Derby26cbe512018-05-24 14:39:01 -0400118 fDrawingManager.reset(new GrDrawingManager(this, prcOptions, textContextOptions,
Robert Phillips7e90be92019-02-15 12:22:59 -0500119 this->singleOwner(),
120 this->explicitlyAllocateGPUResources(),
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500121 this->options().fSortRenderTargets,
122 this->options().fReduceOpListSplitting));
joshualitt7c3a2f82015-03-31 13:32:05 -0700123
Robert Phillipsfde6fa02018-03-02 08:53:14 -0500124 // DDL TODO: we need to think through how the task group & persistent cache
125 // get passed on to/shared between all the DDLRecorders created with this context.
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500126 if (this->options().fExecutor) {
127 fTaskGroup = skstd::make_unique<SkTaskGroup>(*this->options().fExecutor);
Brian Osman51279982017-08-23 10:12:00 -0400128 }
129
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500130 fPersistentCache = this->options().fPersistentCache;
Ethan Nicholasd1b2eec2017-11-01 15:45:43 -0400131
Brian Salomon91a3e522017-06-23 10:58:19 -0400132 return true;
bsalomon@google.comc0af3172012-06-15 14:10:09 +0000133}
134
Robert Phillips4217ea72019-01-30 13:08:28 -0500135sk_sp<GrContextThreadSafeProxy> GrContext::threadSafeProxy() {
136 return fThreadSafeProxy;
137}
138
Robert Phillipsb97da532019-02-12 15:24:12 -0500139GrDrawingManager* GrContext::drawingManager() {
140 return fDrawingManager.get();
141}
142
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400143//////////////////////////////////////////////////////////////////////////////
144
bsalomon2354f842014-07-28 13:48:36 -0700145void GrContext::abandonContext() {
Robert Phillipsa9162df2019-02-11 14:12:03 -0500146 if (this->abandoned()) {
147 return;
148 }
joshualitt1de610a2016-01-06 08:26:09 -0800149
Robert Phillipsa9162df2019-02-11 14:12:03 -0500150 INHERITED::abandonContext();
151
bsalomond309e7a2015-04-30 14:18:54 -0700152 fResourceProvider->abandon();
robertphillips0dfa62c2015-11-16 06:23:31 -0800153
Robert Phillipsa9162df2019-02-11 14:12:03 -0500154 // Need to cleanup the drawing manager first so all the render targets
robertphillips0dfa62c2015-11-16 06:23:31 -0800155 // will be released/forgotten before they too are abandoned.
Robert Phillips6a6de562019-02-15 15:19:15 -0500156 this->drawingManager()->cleanup();
robertphillips0dfa62c2015-11-16 06:23:31 -0800157
bsalomon@google.com205d4602011-04-25 12:43:45 +0000158 // abandon first to so destructors
159 // don't try to free the resources in the API.
bsalomon0ea80f42015-02-11 10:49:59 -0800160 fResourceCache->abandonAll();
bsalomonc8dc1f72014-08-21 13:02:13 -0700161
bsalomon6e2aad42016-04-01 11:54:31 -0700162 fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
Khushalc421ca12018-06-26 14:38:34 -0700163}
164
bsalomon6e2aad42016-04-01 11:54:31 -0700165void GrContext::releaseResourcesAndAbandonContext() {
Brian Salomon614c1a82018-12-19 15:42:06 -0500166 if (this->abandoned()) {
167 return;
168 }
Robert Phillipsa9162df2019-02-11 14:12:03 -0500169
170 INHERITED::abandonContext();
171
bsalomon6e2aad42016-04-01 11:54:31 -0700172 fResourceProvider->abandon();
173
Robert Phillipsa9162df2019-02-11 14:12:03 -0500174 // Need to cleanup the drawing manager first so all the render targets
bsalomon6e2aad42016-04-01 11:54:31 -0700175 // will be released/forgotten before they too are abandoned.
Robert Phillips6a6de562019-02-15 15:19:15 -0500176 this->drawingManager()->cleanup();
bsalomon6e2aad42016-04-01 11:54:31 -0700177
178 // Release all resources in the backend 3D API.
179 fResourceCache->releaseAll();
180
181 fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000182}
183
Brian Salomon1f05d452019-02-08 12:33:08 -0500184void GrContext::resetGLTextureBindings() {
185 if (this->abandoned() || this->backend() != GrBackendApi::kOpenGL) {
186 return;
187 }
188 fGpu->resetTextureBindings();
189}
190
bsalomon@google.com0a208a12013-06-28 18:57:35 +0000191void GrContext::resetContext(uint32_t state) {
joshualitt1de610a2016-01-06 08:26:09 -0800192 ASSERT_SINGLE_OWNER
bsalomon@google.com0a208a12013-06-28 18:57:35 +0000193 fGpu->markContextDirty(state);
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000194}
195
196void GrContext::freeGpuResources() {
joshualitt1de610a2016-01-06 08:26:09 -0800197 ASSERT_SINGLE_OWNER
198
Robert Phillips2184fb72019-02-21 16:11:41 -0500199 // TODO: the glyph cache doesn't hold any GpuResources so this call should not be needed here.
200 // Some slack in the GrTextBlob's implementation requires it though. That could be fixed.
201 this->getGlyphCache()->freeAll();
robertphillips68737822015-10-29 12:12:21 -0700202
Robert Phillips6a6de562019-02-15 15:19:15 -0500203 this->drawingManager()->freeGpuResources();
bsalomon3033b9f2015-04-13 11:09:56 -0700204
205 fResourceCache->purgeAllUnlocked();
bsalomon@google.com27847de2011-02-22 20:59:41 +0000206}
207
Robert Phillips6eba0632018-03-28 12:25:42 -0400208void GrContext::purgeUnlockedResources(bool scratchResourcesOnly) {
209 ASSERT_SINGLE_OWNER
210 fResourceCache->purgeUnlockedResources(scratchResourcesOnly);
211 fResourceCache->purgeAsNeeded();
Robert Phillips2184fb72019-02-21 16:11:41 -0500212
213 // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
214 // place to purge stale blobs
215 this->getTextBlobCache()->purgeStaleBlobs();
Robert Phillips6eba0632018-03-28 12:25:42 -0400216}
217
Jim Van Verth76d917c2017-12-13 09:26:37 -0500218void GrContext::performDeferredCleanup(std::chrono::milliseconds msNotUsed) {
Brian Salomon5e150852017-03-22 14:53:13 -0400219 ASSERT_SINGLE_OWNER
Chris Dalton6c3879d2018-11-01 11:13:19 -0600220
221 auto purgeTime = GrStdSteadyClock::now() - msNotUsed;
222
Jim Van Verth76d917c2017-12-13 09:26:37 -0500223 fResourceCache->purgeAsNeeded();
Chris Dalton6c3879d2018-11-01 11:13:19 -0600224 fResourceCache->purgeResourcesNotUsedSince(purgeTime);
225
Robert Phillips6a6de562019-02-15 15:19:15 -0500226 if (auto ccpr = this->drawingManager()->getCoverageCountingPathRenderer()) {
Robert Phillipsa41c6852019-02-07 10:44:10 -0500227 ccpr->purgeCacheEntriesOlderThan(this->proxyProvider(), purgeTime);
Chris Dalton6c3879d2018-11-01 11:13:19 -0600228 }
Jim Van Verth76d917c2017-12-13 09:26:37 -0500229
Robert Phillips2184fb72019-02-21 16:11:41 -0500230 // The textBlob Cache doesn't actually hold any GPU resource but this is a convenient
231 // place to purge stale blobs
232 this->getTextBlobCache()->purgeStaleBlobs();
Brian Salomon5e150852017-03-22 14:53:13 -0400233}
234
Derek Sollenberger5480a182017-05-25 16:43:59 -0400235void GrContext::purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources) {
236 ASSERT_SINGLE_OWNER
237 fResourceCache->purgeUnlockedResources(bytesToPurge, preferScratchResources);
238}
239
commit-bot@chromium.org95c20032014-05-09 14:29:32 +0000240void GrContext::getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const {
joshualitt1de610a2016-01-06 08:26:09 -0800241 ASSERT_SINGLE_OWNER
242
bsalomon71cb0c22014-11-14 12:10:14 -0800243 if (resourceCount) {
bsalomon0ea80f42015-02-11 10:49:59 -0800244 *resourceCount = fResourceCache->getBudgetedResourceCount();
bsalomon71cb0c22014-11-14 12:10:14 -0800245 }
246 if (resourceBytes) {
bsalomon0ea80f42015-02-11 10:49:59 -0800247 *resourceBytes = fResourceCache->getBudgetedResourceBytes();
bsalomon71cb0c22014-11-14 12:10:14 -0800248 }
commit-bot@chromium.orgd8a57af2014-03-19 21:19:16 +0000249}
250
Derek Sollenbergeree479142017-05-24 11:41:33 -0400251size_t GrContext::getResourceCachePurgeableBytes() const {
252 ASSERT_SINGLE_OWNER
253 return fResourceCache->getPurgeableBytes();
254}
255
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000256////////////////////////////////////////////////////////////////////////////////
257
Robert Phillipsbb606772019-02-04 17:50:57 -0500258int GrContext::maxTextureSize() const { return this->caps()->maxTextureSize(); }
Brian Salomonf932a632018-04-05 12:46:09 -0400259
Robert Phillipsbb606772019-02-04 17:50:57 -0500260int GrContext::maxRenderTargetSize() const { return this->caps()->maxRenderTargetSize(); }
Brian Salomonf932a632018-04-05 12:46:09 -0400261
Brian Salomonbdecacf2018-02-02 20:32:49 -0500262bool GrContext::colorTypeSupportedAsImage(SkColorType colorType) const {
Brian Osman2b23c4b2018-06-01 12:25:08 -0400263 GrPixelConfig config = SkColorType2GrPixelConfig(colorType);
Robert Phillipsbb606772019-02-04 17:50:57 -0500264 return this->caps()->isConfigTexturable(config);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500265}
266
267int GrContext::maxSurfaceSampleCountForColorType(SkColorType colorType) const {
Brian Osman2b23c4b2018-06-01 12:25:08 -0400268 GrPixelConfig config = SkColorType2GrPixelConfig(colorType);
Robert Phillipsbb606772019-02-04 17:50:57 -0500269 return this->caps()->maxRenderTargetSampleCount(config);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500270}
271
272////////////////////////////////////////////////////////////////////////////////
273
bsalomonb77a9072016-09-07 10:02:04 -0700274void GrContext::flush() {
joshualitt1de610a2016-01-06 08:26:09 -0800275 ASSERT_SINGLE_OWNER
robertphillipsea461502015-05-26 11:38:03 -0700276 RETURN_IF_ABANDONED
Robert Phillips7ee385e2017-03-30 08:02:11 -0400277
Robert Phillips6a6de562019-02-15 15:19:15 -0500278 this->drawingManager()->flush(nullptr);
Robert Phillips7ee385e2017-03-30 08:02:11 -0400279}
280
Greg Daniel51316782017-08-02 15:10:09 +0000281GrSemaphoresSubmitted GrContext::flushAndSignalSemaphores(int numSemaphores,
282 GrBackendSemaphore signalSemaphores[]) {
283 ASSERT_SINGLE_OWNER
Robert Phillipsa9162df2019-02-11 14:12:03 -0500284 if (this->abandoned()) {
285 return GrSemaphoresSubmitted::kNo;
286 }
Greg Daniel51316782017-08-02 15:10:09 +0000287
Robert Phillips6a6de562019-02-15 15:19:15 -0500288 return this->drawingManager()->flush(nullptr, numSemaphores, signalSemaphores);
Greg Daniel51316782017-08-02 15:10:09 +0000289}
290
Greg Daniela870b462019-01-08 15:49:46 -0500291////////////////////////////////////////////////////////////////////////////////
292
293void GrContext::storeVkPipelineCacheData() {
294 if (fGpu) {
295 fGpu->storeVkPipelineCacheData();
296 }
297}
298
299////////////////////////////////////////////////////////////////////////////////
300
Brian Salomonaff329b2017-08-11 09:40:37 -0400301std::unique_ptr<GrFragmentProcessor> GrContext::createPMToUPMEffect(
Brian Osman5ea96bf2018-10-02 14:58:05 -0400302 std::unique_ptr<GrFragmentProcessor> fp) {
Robert Phillips757914d2017-01-25 15:48:30 -0500303 ASSERT_SINGLE_OWNER
Brian Osman5ea96bf2018-10-02 14:58:05 -0400304 // We should have already called this->validPMUPMConversionExists() in this case
305 SkASSERT(fDidTestPMConversions);
306 // ...and it should have succeeded
307 SkASSERT(this->validPMUPMConversionExists());
Brian Osman409e74f2017-04-17 11:48:28 -0400308
Brian Osman5ea96bf2018-10-02 14:58:05 -0400309 return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToUnpremul);
Robert Phillips757914d2017-01-25 15:48:30 -0500310}
311
Brian Salomonaff329b2017-08-11 09:40:37 -0400312std::unique_ptr<GrFragmentProcessor> GrContext::createUPMToPMEffect(
Brian Osman5ea96bf2018-10-02 14:58:05 -0400313 std::unique_ptr<GrFragmentProcessor> fp) {
joshualitt1de610a2016-01-06 08:26:09 -0800314 ASSERT_SINGLE_OWNER
Brian Osman5ea96bf2018-10-02 14:58:05 -0400315 // We should have already called this->validPMUPMConversionExists() in this case
316 SkASSERT(fDidTestPMConversions);
317 // ...and it should have succeeded
318 SkASSERT(this->validPMUPMConversionExists());
Brian Osman409e74f2017-04-17 11:48:28 -0400319
Brian Osman5ea96bf2018-10-02 14:58:05 -0400320 return GrConfigConversionEffect::Make(std::move(fp), PMConversion::kToPremul);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +0000321}
322
Brian Osman409e74f2017-04-17 11:48:28 -0400323bool GrContext::validPMUPMConversionExists() {
joshualitt1de610a2016-01-06 08:26:09 -0800324 ASSERT_SINGLE_OWNER
Brian Osman409e74f2017-04-17 11:48:28 -0400325 if (!fDidTestPMConversions) {
Brian Osman28804f32017-04-20 10:24:36 -0400326 fPMUPMConversionsRoundTrip = GrConfigConversionEffect::TestForPreservingPMConversions(this);
Brian Osman409e74f2017-04-17 11:48:28 -0400327 fDidTestPMConversions = true;
328 }
329
bsalomon636e8022015-07-29 06:08:46 -0700330 // The PM<->UPM tests fail or succeed together so we only need to check one.
Brian Osman28804f32017-04-20 10:24:36 -0400331 return fPMUPMConversionsRoundTrip;
bsalomon636e8022015-07-29 06:08:46 -0700332}
333
Khushal3e7548c2018-05-23 15:45:01 -0700334bool GrContext::supportsDistanceFieldText() const {
Robert Phillipsbb606772019-02-04 17:50:57 -0500335 return this->caps()->shaderCaps()->supportsDistanceFieldText();
Khushal3e7548c2018-05-23 15:45:01 -0700336}
337
bsalomon37f9a262015-02-02 13:00:10 -0800338//////////////////////////////////////////////////////////////////////////////
339
Robert Phillipsfc711a22018-02-13 17:03:00 -0500340// DDL TODO: remove 'maxResources'
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500341void GrContext::getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const {
joshualitt1de610a2016-01-06 08:26:09 -0800342 ASSERT_SINGLE_OWNER
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500343 if (maxResources) {
344 *maxResources = fResourceCache->getMaxResourceCount();
bsalomon37f9a262015-02-02 13:00:10 -0800345 }
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500346 if (maxResourceBytes) {
347 *maxResourceBytes = fResourceCache->getMaxResourceBytes();
bsalomon37f9a262015-02-02 13:00:10 -0800348 }
349}
350
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500351void GrContext::setResourceCacheLimits(int maxResources, size_t maxResourceBytes) {
joshualitt1de610a2016-01-06 08:26:09 -0800352 ASSERT_SINGLE_OWNER
Robert Phillips8d1e67e2017-12-04 13:48:14 -0500353 fResourceCache->setLimits(maxResources, maxResourceBytes);
bsalomon37f9a262015-02-02 13:00:10 -0800354}
355
ericrk0a5fa482015-09-15 14:16:10 -0700356//////////////////////////////////////////////////////////////////////////////
ericrk0a5fa482015-09-15 14:16:10 -0700357void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
joshualitt1de610a2016-01-06 08:26:09 -0800358 ASSERT_SINGLE_OWNER
ericrk0a5fa482015-09-15 14:16:10 -0700359 fResourceCache->dumpMemoryStatistics(traceMemoryDump);
Khushal71652e22018-10-29 13:05:36 -0700360 traceMemoryDump->dumpNumericValue("skia/gr_text_blob_cache", "size", "bytes",
Robert Phillips2184fb72019-02-21 16:11:41 -0500361 this->getTextBlobCache()->usedBytes());
ericrk0a5fa482015-09-15 14:16:10 -0700362}
Brian Osman71a18892017-08-10 10:23:25 -0400363