Rename GrContext::uniqueID to contextID and hide it

rphilli · Skia Commit-Bot · commit fd0d97092b4a · 2019-02-01T16:18:23.000Z
The GrContext's ID isn't really unique any more (since it can be shared among a family of contexts). Change its name to reflect the new reality. Additionally, no client seems to be using it so make it private. Change-Id: Ibb9004d699fe6ca7876b3be94142e612b5b9efbd Reviewed-on: https://skia-review.googlesource.com/c/188308 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/include/gpu/GrContextThreadSafeProxy.h b/include/gpu/GrContextThreadSafeProxy.h
@@ -14,6 +14,7 @@
 class GrBackendFormat;
 class GrCaps;
 class GrContext;
+class GrContext_Base;
 class GrContextThreadSafeProxyPriv;
 class GrSkSLFPFactoryCache;
 struct SkImageInfo;
@@ -27,7 +28,7 @@ class SK_API GrContextThreadSafeProxy : public SkRefCnt {
 public:
     ~GrContextThreadSafeProxy() override;
 
-    bool matches(GrContext* context) const;
+    bool matches(GrContext_Base* context) const;
 
     /**
      *  Create a surface characterization for a DDL that will be replayed into the GrContext
@@ -68,7 +69,7 @@ class SK_API GrContextThreadSafeProxy : public SkRefCnt {
 
     bool operator==(const GrContextThreadSafeProxy& that) const {
         // Each GrContext should only ever have a single thread-safe proxy.
-        SkASSERT((this == &that) == (fContextUniqueID == that.fContextUniqueID));
+        SkASSERT((this == &that) == (fContextID == that.fContextID));
         return this == &that;
     }
 
@@ -87,8 +88,8 @@ class SK_API GrContextThreadSafeProxy : public SkRefCnt {
                              sk_sp<GrSkSLFPFactoryCache> cache);
 
     sk_sp<const GrCaps>         fCaps;
-    const uint32_t              fContextUniqueID;
-    const GrBackendApi             fBackend;
+    const uint32_t              fContextID;
+    const GrBackendApi          fBackend;
     const GrContextOptions      fOptions;
     sk_sp<GrSkSLFPFactoryCache> fFPFactoryCache;
 
diff --git a/include/private/GrContext_Base.h b/include/private/GrContext_Base.h
@@ -25,15 +25,6 @@ class SK_API GrContext_Base : public SkRefCnt {
      */
     GrBackendApi backend() const { return fBackend; }
 
-    /**
-     * An identifier for this context. The id is used by all compatible contexts. For example,
-     * if SkImages are created on one thread using an image creation context, then fed into a
-     * DDL Recorder on second thread (which has a recording context) and finally replayed on
-     * a third thread with a direct context, then all three contexts will report the same id.
-     * It is an error for an image to be used with contexts that report different ids.
-     */
-    uint32_t uniqueID() const { return fUniqueID; }
-
     // Provides access to functions that aren't part of the public API.
     GrBaseContextPriv priv();
     const GrBaseContextPriv priv() const;
@@ -43,14 +34,23 @@ class SK_API GrContext_Base : public SkRefCnt {
 
     GrContext_Base(GrBackendApi backend, uint32_t uniqueID);
 
+    /**
+     * An identifier for this context. The id is used by all compatible contexts. For example,
+     * if SkImages are created on one thread using an image creation context, then fed into a
+     * DDL Recorder on second thread (which has a recording context) and finally replayed on
+     * a third thread with a direct context, then all three contexts will report the same id.
+     * It is an error for an image to be used with contexts that report different ids.
+     */
+    uint32_t contextID() const { return fContextID; }
+
     GrContext_Base* asBaseContext() { return this; }
     virtual GrImageContext* asImageContext() { return nullptr; }
     virtual GrRecordingContext* asRecordingContext() { return nullptr; }
     virtual GrContext* asDirectContext() { return nullptr; }
 
 private:
     const GrBackendApi fBackend;
-    const uint32_t     fUniqueID;
+    const uint32_t     fContextID;
 
     typedef SkRefCnt INHERITED;
 };
diff --git a/src/core/SkSpecialImage.cpp b/src/core/SkSpecialImage.cpp
@@ -192,7 +192,7 @@ sk_sp<SkSpecialImage> SkSpecialImage::MakeFromImage(GrContext* context,
 
 #if SK_SUPPORT_GPU
     if (sk_sp<GrTextureProxy> proxy = as_IB(image)->asTextureProxyRef()) {
-        if (as_IB(image)->contextID() != context->uniqueID()) {
+        if (as_IB(image)->contextID() != context->contextPriv().contextID()) {
             return nullptr;
         }
 
diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp
@@ -56,7 +56,8 @@ GrBackendTextureImageGenerator::Make(sk_sp<GrTexture> texture, GrSurfaceOrigin o
     SkImageInfo info = SkImageInfo::Make(texture->width(), texture->height(), colorType, alphaType,
                                          std::move(colorSpace));
     return std::unique_ptr<SkImageGenerator>(new GrBackendTextureImageGenerator(
-          info, texture.get(), origin, context->uniqueID(), std::move(semaphore), backendTexture));
+          info, texture.get(), origin, context->contextPriv().contextID(),
+          std::move(semaphore), backendTexture));
 }
 
 GrBackendTextureImageGenerator::GrBackendTextureImageGenerator(const SkImageInfo& info,
@@ -104,7 +105,7 @@ sk_sp<GrTextureProxy> GrBackendTextureImageGenerator::onGenerateTexture(
     fBorrowingMutex.acquire();
     sk_sp<GrReleaseProcHelper> releaseProcHelper;
     if (SK_InvalidGenID != fRefHelper->fBorrowingContextID) {
-        if (fRefHelper->fBorrowingContextID != context->uniqueID()) {
+        if (fRefHelper->fBorrowingContextID != context->contextPriv().contextID()) {
             fBorrowingMutex.release();
             return nullptr;
         } else {
@@ -121,10 +122,10 @@ sk_sp<GrTextureProxy> GrBackendTextureImageGenerator::onGenerateTexture(
                                                         fRefHelper));
         fRefHelper->fBorrowingContextReleaseProc = releaseProcHelper.get();
     }
-    fRefHelper->fBorrowingContextID = context->uniqueID();
+    fRefHelper->fBorrowingContextID = context->contextPriv().contextID();
     fBorrowingMutex.release();
 
-    SkASSERT(fRefHelper->fBorrowingContextID == context->uniqueID());
+    SkASSERT(fRefHelper->fBorrowingContextID == context->contextPriv().contextID());
 
     GrSurfaceDesc desc;
     desc.fWidth = fBackendTexture.width();
diff --git a/src/gpu/GrBaseContextPriv.h b/src/gpu/GrBaseContextPriv.h
@@ -16,6 +16,7 @@
 class GrBaseContextPriv {
 public:
     // from GrContext_Base
+    uint32_t contextID() const { return fContext->contextID(); }
 
 private:
     explicit GrBaseContextPriv(GrContext_Base* context) : fContext(context) {}
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
@@ -74,13 +74,13 @@ bool GrContext::initCommon(const GrContextOptions& options) {
 
     if (fGpu) {
         fCaps = fGpu->refCaps();
-        fResourceCache = new GrResourceCache(fCaps.get(), &fSingleOwner, this->uniqueID());
+        fResourceCache = new GrResourceCache(fCaps.get(), &fSingleOwner, this->contextID());
         fResourceProvider = new GrResourceProvider(fGpu.get(), fResourceCache, &fSingleOwner,
                                                    options.fExplicitlyAllocateGPUResources);
         fProxyProvider =
                 new GrProxyProvider(fResourceProvider, fResourceCache, fCaps, &fSingleOwner);
     } else {
-        fProxyProvider = new GrProxyProvider(this->uniqueID(), fCaps, &fSingleOwner);
+        fProxyProvider = new GrProxyProvider(this->contextID(), fCaps, &fSingleOwner);
     }
 
     if (fResourceCache) {
@@ -131,8 +131,7 @@ bool GrContext::initCommon(const GrContextOptions& options) {
 
     fGlyphCache = new GrStrikeCache(fCaps.get(), options.fGlyphCacheTextureMaximumBytes);
 
-    fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB,
-                                             this, this->uniqueID()));
+    fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB, this, this->contextID()));
 
     // DDL TODO: we need to think through how the task group & persistent cache
     // get passed on to/shared between all the DDLRecorders created with this context.
diff --git a/src/gpu/GrContextPriv.h b/src/gpu/GrContextPriv.h
@@ -30,6 +30,7 @@ class GrContextPriv {
 public:
 
     // from GrContext_Base
+    uint32_t contextID() const { return fContext->contextID(); }
 
     // from GrImageContext
 
diff --git a/src/gpu/GrContextThreadSafeProxy.cpp b/src/gpu/GrContextThreadSafeProxy.cpp
@@ -8,26 +8,27 @@
 #include "GrContextThreadSafeProxy.h"
 #include "GrContextThreadSafeProxyPriv.h"
 
+#include "GrBaseContextPriv.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrSkSLFPFactoryCache.h"
 #include "SkSurface_Gpu.h"
 #include "SkSurfaceCharacterization.h"
 
-GrContextThreadSafeProxy::GrContextThreadSafeProxy(sk_sp<const GrCaps> caps, uint32_t uniqueID,
+GrContextThreadSafeProxy::GrContextThreadSafeProxy(sk_sp<const GrCaps> caps, uint32_t contextID,
                                                    GrBackendApi backend,
                                                    const GrContextOptions& options,
                                                    sk_sp<GrSkSLFPFactoryCache> cache)
         : fCaps(std::move(caps))
-        , fContextUniqueID(uniqueID)
+        , fContextID(contextID)
         , fBackend(backend)
         , fOptions(options)
         , fFPFactoryCache(std::move(cache)) {}
 
 GrContextThreadSafeProxy::~GrContextThreadSafeProxy() = default;
 
-bool GrContextThreadSafeProxy::matches(GrContext* context) const {
-    return context->uniqueID() == fContextUniqueID;
+bool GrContextThreadSafeProxy::matches(GrContext_Base* context) const {
+    return context->priv().contextID() == fContextID;
 }
 
 SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
diff --git a/src/gpu/GrContextThreadSafeProxyPriv.h b/src/gpu/GrContextThreadSafeProxyPriv.h
@@ -21,7 +21,7 @@ class GrContextThreadSafeProxyPriv {
 
     const GrCaps* caps() const { return fProxy->fCaps.get(); }
     sk_sp<const GrCaps> refCaps() const { return fProxy->fCaps; }
-    uint32_t contextUniqueID() const { return fProxy->fContextUniqueID; }
+    uint32_t contextID() const { return fProxy->fContextID; }
     GrBackendApi backend() const { return fProxy->fBackend; }
     sk_sp<GrSkSLFPFactoryCache> fpFactoryCache() const;
 
diff --git a/src/gpu/GrContext_Base.cpp b/src/gpu/GrContext_Base.cpp
@@ -17,9 +17,9 @@ static int32_t next_id() {
 }
 
 GrContext_Base::GrContext_Base(GrBackendApi backend,
-                               uint32_t uniqueID)
+                               uint32_t contextID)
         : fBackend(backend)
-        , fUniqueID(SK_InvalidGenID == uniqueID ? next_id() : uniqueID) {
+        , fContextID(SK_InvalidGenID == contextID ? next_id() : contextID) {
 }
 
 GrContext_Base::~GrContext_Base() {
diff --git a/src/gpu/GrDDLContext.cpp b/src/gpu/GrDDLContext.cpp
@@ -18,7 +18,7 @@
 class SK_API GrDDLContext : public GrContext {
 public:
     GrDDLContext(sk_sp<GrContextThreadSafeProxy> proxy)
-            : INHERITED(proxy->priv().backend(), proxy->priv().contextUniqueID()) {
+            : INHERITED(proxy->priv().backend(), proxy->priv().contextID()) {
         fCaps = proxy->priv().refCaps();
         fFPFactoryCache = proxy->priv().fpFactoryCache();
         SkASSERT(fFPFactoryCache);
diff --git a/src/gpu/GrDirectContext.cpp b/src/gpu/GrDirectContext.cpp
@@ -63,7 +63,7 @@ class SK_API GrDirectContext : public GrContext {
         SkASSERT(!fThreadSafeProxy);
         SkASSERT(!fFPFactoryCache);
         fFPFactoryCache.reset(new GrSkSLFPFactoryCache());
-        fThreadSafeProxy.reset(new GrContextThreadSafeProxy(fCaps, this->uniqueID(),
+        fThreadSafeProxy.reset(new GrContextThreadSafeProxy(fCaps, this->contextID(),
                                                             this->backend(),
                                                             options, fFPFactoryCache));
 
diff --git a/src/gpu/GrImageContextPriv.h b/src/gpu/GrImageContextPriv.h
@@ -16,6 +16,7 @@
 class GrImageContextPriv {
 public:
     // from GrContext_Base
+    uint32_t contextID() const { return fContext->contextID(); }
 
     // from GrImageContext
 
diff --git a/src/gpu/GrOnFlushResourceProvider.cpp b/src/gpu/GrOnFlushResourceProvider.cpp
@@ -94,8 +94,8 @@ sk_sp<const GrBuffer> GrOnFlushResourceProvider::findOrMakeStaticBuffer(GrBuffer
     return buffer;
 }
 
-uint32_t GrOnFlushResourceProvider::contextUniqueID() const {
-    return fDrawingMgr->getContext()->uniqueID();
+uint32_t GrOnFlushResourceProvider::contextID() const {
+    return fDrawingMgr->getContext()->contextPriv().contextID();
 }
 
 const GrCaps* GrOnFlushResourceProvider::caps() const {
diff --git a/src/gpu/GrOnFlushResourceProvider.h b/src/gpu/GrOnFlushResourceProvider.h
@@ -92,7 +92,7 @@ class GrOnFlushResourceProvider {
     sk_sp<const GrBuffer> findOrMakeStaticBuffer(GrBufferType, size_t, const void* data,
                                                  const GrUniqueKey&);
 
-    uint32_t contextUniqueID() const;
+    uint32_t contextID() const;
     const GrCaps* caps() const;
 
 private:
diff --git a/src/gpu/GrPathRendererChain.cpp b/src/gpu/GrPathRendererChain.cpp
@@ -41,7 +41,7 @@ GrPathRendererChain::GrPathRendererChain(GrContext* context, const Options& opti
         using AllowCaching = GrCoverageCountingPathRenderer::AllowCaching;
         if (auto ccpr = GrCoverageCountingPathRenderer::CreateIfSupported(
                                 caps, AllowCaching(options.fAllowPathMaskCaching),
-                                context->uniqueID())) {
+                                context->contextPriv().contextID())) {
             fCoverageCountingPathRenderer = ccpr.get();
             context->contextPriv().addOnFlushCallbackObject(fCoverageCountingPathRenderer);
             fChain.push_back(std::move(ccpr));
diff --git a/src/gpu/GrRecordingContextPriv.h b/src/gpu/GrRecordingContextPriv.h
@@ -16,6 +16,7 @@
 class GrRecordingContextPriv {
 public:
     // from GrContext_Base
+    uint32_t contextID() const { return fContext->contextID(); }
 
     // from GrImageContext
 
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -374,7 +374,7 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) {
             SkASSERT(proxy->origin() == kTopLeft_GrSurfaceOrigin);
             fProxyProvider->assignUniqueKeyToProxy(maskKey, proxy.get());
             args.fShape->addGenIDChangeListener(
-                    sk_make_sp<PathInvalidator>(maskKey, args.fContext->uniqueID()));
+                    sk_make_sp<PathInvalidator>(maskKey, args.fContext->contextPriv().contextID()));
         }
     }
     if (inverseFilled) {
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -960,8 +960,8 @@ GR_DRAW_OP_TEST_DEFINE(SmallPathOp) {
     using PathTestStruct = GrSmallPathRenderer::PathTestStruct;
     static PathTestStruct gTestStruct;
 
-    if (context->uniqueID() != gTestStruct.fContextID) {
-        gTestStruct.fContextID = context->uniqueID();
+    if (context->contextPriv().contextID() != gTestStruct.fContextID) {
+        gTestStruct.fContextID = context->contextPriv().contextID();
         gTestStruct.reset();
         const GrBackendFormat format =
                 context->contextPriv().caps()->getBackendFormatFromColorType(kAlpha_8_SkColorType);
diff --git a/src/gpu/text/GrTextContext.cpp b/src/gpu/text/GrTextContext.cpp
@@ -9,7 +9,7 @@
 
 #include "GrCaps.h"
 #include "GrContext.h"
-#include "GrContextPriv.h"
+#include "GrRecordingContextPriv.h"
 #include "GrSDFMaskFilter.h"
 #include "GrTextBlobCache.h"
 #include "SkDistanceFieldGen.h"
@@ -210,8 +210,8 @@ GR_DRAW_OP_TEST_DEFINE(GrAtlasTextOp) {
     static std::unique_ptr<GrTextContext> gTextContext;
     static SkSurfaceProps gSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
 
-    if (context->uniqueID() != gContextID) {
-        gContextID = context->uniqueID();
+    if (context->priv().contextID() != gContextID) {
+        gContextID = context->priv().contextID();
         gTextContext = GrTextContext::Make(GrTextContext::Options());
     }
 
diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h
@@ -50,6 +50,7 @@ class SkImage_Base : public SkImage {
                               int srcX, int srcY, CachingHint) const = 0;
 
     virtual GrContext* context() const { return nullptr; }
+    // TODO: remove this contextID and use GrContext_Base::matches
     virtual uint32_t contextID() const { return 0; }
 #if SK_SUPPORT_GPU
     virtual GrTextureProxy* peekProxy() const { return nullptr; }
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
@@ -351,7 +351,7 @@ sk_sp<SkImage> SkImage::makeTextureImage(GrContext* context, SkColorSpace* dstCo
         return nullptr;
     }
     if (uint32_t incumbentID = as_IB(this)->contextID()) {
-        if (incumbentID != context->uniqueID()) {
+        if (incumbentID != context->contextPriv().contextID()) {
             return nullptr;
         }
         sk_sp<GrTextureProxy> proxy = as_IB(this)->asTextureProxyRef();
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
@@ -31,6 +31,13 @@ SkImage_GpuBase::~SkImage_GpuBase() {}
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
+#if GR_TEST_UTILS
+void SkImage_GpuBase::resetContext(sk_sp<GrContext> newContext) {
+    SkASSERT(fContext->contextPriv().contextID() == newContext->contextPriv().contextID());
+    fContext = newContext;
+}
+#endif
+
 bool SkImage_GpuBase::ValidateBackendTexture(GrContext* ctx, const GrBackendTexture& tex,
                                              GrPixelConfig* config, SkColorType ct, SkAlphaType at,
                                              sk_sp<SkColorSpace> cs) {
@@ -53,6 +60,10 @@ bool SkImage_GpuBase::ValidateBackendTexture(GrContext* ctx, const GrBackendText
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
+uint32_t SkImage_GpuBase::contextID() const {
+    return fContext->contextPriv().contextID();
+}
+
 bool SkImage_GpuBase::getROPixels(SkBitmap* dst, CachingHint chint) const {
     if (!fContext->contextPriv().resourceProvider()) {
         // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
@@ -200,7 +211,7 @@ bool SkImage_GpuBase::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels,
 sk_sp<GrTextureProxy> SkImage_GpuBase::asTextureProxyRef(GrContext* context,
                                                          const GrSamplerState& params,
                                                          SkScalar scaleAdjust[2]) const {
-    if (context->uniqueID() != fContext->uniqueID()) {
+    if (context->contextPriv().contextID() != fContext->contextPriv().contextID()) {
         SkASSERT(0);
         return nullptr;
     }
@@ -498,8 +509,8 @@ sk_sp<GrTextureProxy> SkImage_GpuBase::MakePromiseImageLazyProxy(
             }
             tex->resourcePriv().setUniqueKey(fLastFulfilledKey);
             SkASSERT(fContextID == SK_InvalidUniqueID ||
-                     fContextID == tex->getContext()->uniqueID());
-            fContextID = tex->getContext()->uniqueID();
+                     fContextID == tex->getContext()->contextPriv().contextID());
+            fContextID = tex->getContext()->contextPriv().contextID();
             promiseTexture->addKeyToInvalidate(fContextID, fLastFulfilledKey);
             return std::move(tex);
         }
diff --git a/src/image/SkImage_GpuBase.h b/src/image/SkImage_GpuBase.h
@@ -24,7 +24,7 @@ class SkImage_GpuBase : public SkImage_Base {
     ~SkImage_GpuBase() override;
 
     GrContext* context() const final { return fContext.get(); }
-    uint32_t contextID() const final { return fContext->uniqueID(); }
+    uint32_t contextID() const final;
 
     bool getROPixels(SkBitmap*, CachingHint) const final;
     sk_sp<SkImage> onMakeSubset(const SkIRect& subset) const final;
@@ -53,10 +53,7 @@ class SkImage_GpuBase : public SkImage_Base {
     bool onIsValid(GrContext*) const final;
 
 #if GR_TEST_UTILS
-    void resetContext(sk_sp<GrContext> newContext) {
-        SkASSERT(fContext->uniqueID() == newContext->uniqueID());
-        fContext = newContext;
-    }
+    void resetContext(sk_sp<GrContext> newContext);
 #endif
 
     static bool ValidateBackendTexture(GrContext* ctx, const GrBackendTexture& tex,
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ sk_sp<SkSpecialImage> SkSpecialImage::MakeFromImage(GrContext* context,`
`192`	`192`
`193`	`193`	`#if SK_SUPPORT_GPU`
`194`	`194`	`if (sk_sp<GrTextureProxy> proxy = as_IB(image)->asTextureProxyRef()) {`
`195`		`- if (as_IB(image)->contextID() != context->uniqueID()) {`
	`195`	`+ if (as_IB(image)->contextID() != context->contextPriv().contextID()) {`
`196`	`196`	`return nullptr;`
`197`	`197`	`}`
`198`	`198`
Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,9 @@ static int32_t next_id() {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`GrContext_Base::GrContext_Base(GrBackendApi backend,`
`20`		`- uint32_t uniqueID)`
	`20`	`+ uint32_t contextID)`
`21`	`21`	`: fBackend(backend)`
`22`		`- , fUniqueID(SK_InvalidGenID == uniqueID ? next_id() : uniqueID) {`
	`22`	`+ , fContextID(SK_InvalidGenID == contextID ? next_id() : contextID) {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`GrContext_Base::~GrContext_Base() {`