Revert "Move atlas manager creation to GrContext derived classes"

This reverts commit e5b7ceeac865fb8a3bab82a73d65752c78682718.

Reason for revert: Breaking Mus/Viz tests in Chrome roll

Original change's description:
> Move atlas manager creation to GrContext derived classes
> 
> This CL relies on: https://skia-review.googlesource.com/c/skia/+/108001 (Fission GrAtlasGlyphCache in two)
> 
> TBR=bsalomon@google.com
> Change-Id: Ic3f91cea2238221b970f8ebbda99b10202925cd8
> Reviewed-on: https://skia-review.googlesource.com/110621
> Commit-Queue: Robert Phillips <robertphillips@google.com>
> Reviewed-by: Greg Daniel <egdaniel@google.com>

TBR=egdaniel@google.com,jvanverth@google.com,bsalomon@google.com,robertphillips@google.com

Change-Id: I3973463b7b837145d9732171a91d82f0f0cea148
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/110821
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

4 files changed, 49 insertions, 125 deletions

diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 1b43d99f2e..ff4ec5f677 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -36,7 +36,6 @@ class GrRenderTargetContext;
 class GrResourceEntry;
 class GrResourceCache;
 class GrResourceProvider;
-class GrRestrictedAtlasManager;
 class GrSamplerState;
 class GrSurfaceProxy;
 class GrSwizzle;
@@ -128,7 +127,7 @@ public:
      * The typical use case for this function is that the underlying 3D context was lost and further
      * API calls may crash.
      */
-    virtual void abandonContext();
+    void abandonContext();
 
     /**
      * This is similar to abandonContext() however the underlying 3D context is not yet lost and
@@ -139,7 +138,7 @@ public:
      * but can't guarantee that GrContext will be destroyed first (perhaps because it may be ref'ed
      * elsewhere by either the client or Skia objects).
      */
-    virtual void releaseResourcesAndAbandonContext();
+    void releaseResourcesAndAbandonContext();
 
     ///////////////////////////////////////////////////////////////////////////
     // Resource Cache
@@ -184,7 +183,7 @@ public:
      * Frees GPU created by the context. Can be called to reduce GPU memory
      * pressure.
      */
-    virtual void freeGpuResources();
+    void freeGpuResources();
 
     /**
      * Purge all the unlocked resources from the cache.
@@ -359,15 +358,9 @@ protected:
     GrContext(GrContextThreadSafeProxy*);
     GrContext(GrBackend);
 
-    virtual bool init(const GrContextOptions&); // init must be called after either constructor.
-
-    virtual GrAtlasManager* onGetFullAtlasManager() = 0;
-    virtual GrRestrictedAtlasManager* onGetRestrictedAtlasManager() = 0;
-
-    sk_sp<const GrCaps>                     fCaps;
-
 private:
     sk_sp<GrGpu>                            fGpu;
+    sk_sp<const GrCaps>                     fCaps;
     GrResourceCache*                        fResourceCache;
     GrResourceProvider*                     fResourceProvider;
     GrProxyProvider*                        fProxyProvider;
@@ -375,6 +368,7 @@ private:
     sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
 
     GrGlyphCache*                           fGlyphCache;
+    GrAtlasManager*                         fFullAtlasManager;
     std::unique_ptr<GrTextBlobCache>        fTextBlobCache;
 
     bool                                    fDisableGpuYUVConversion;
@@ -410,6 +404,8 @@ private:
     // TODO: have the GrClipStackClip use renderTargetContexts and rm this friending
     friend class GrContextPriv;
 
+    bool init(const GrContextOptions&); // init must be called after either constructor.
+
     /**
      * These functions create premul <-> unpremul effects. If the second argument is 'true', they
      * use the specialized round-trip effects from GrConfigConversionEffect, otherwise they
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index c61a6c189e..6fbc4fe04f 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -64,123 +64,22 @@ SkASSERT(!(P) || !((P)->priv().peekTexture()) || (P)->priv().peekTexture()->getC
 
 class SK_API GrDirectContext : public GrContext {
 public:
-    GrDirectContext(GrBackend backend)
-            : INHERITED(backend)
-            , fFullAtlasManager(nullptr) {
-    }
-
-    ~GrDirectContext() override {
-        this->flush();
-
-        delete fFullAtlasManager;
-    }
-
-    void abandonContext() override {
-        INHERITED::abandonContext();
-        fFullAtlasManager->freeAll();
-    }
-
-    void releaseResourcesAndAbandonContext() override {
-        INHERITED::releaseResourcesAndAbandonContext();
-        fFullAtlasManager->freeAll();
-    }
-
-    void freeGpuResources() override {
-        this->flush();
-        fFullAtlasManager->freeAll();
-
-        INHERITED::freeGpuResources();
-    }
+    GrDirectContext(GrBackend backend) : INHERITED(backend) { }
 
 protected:
-    bool init(const GrContextOptions& options) override {
-        if (!INHERITED::init(options)) {
-            return false;
-        }
-
-        GrDrawOpAtlas::AllowMultitexturing allowMultitexturing;
-        if (GrContextOptions::Enable::kNo == options.fAllowMultipleGlyphCacheTextures ||
-            // multitexturing supported only if range can represent the index + texcoords fully
-            !(fCaps->shaderCaps()->floatIs32Bits() || fCaps->shaderCaps()->integerSupport())) {
-            allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kNo;
-        } else {
-            allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kYes;
-        }
-
-        GrGlyphCache* glyphCache = this->contextPriv().getGlyphCache();
-        GrProxyProvider* proxyProvider = this->contextPriv().proxyProvider();
-
-        fFullAtlasManager = new GrAtlasManager(proxyProvider, glyphCache,
-                                               options.fGlyphCacheTextureMaximumBytes,
-                                               allowMultitexturing);
-        this->contextPriv().addOnFlushCallbackObject(fFullAtlasManager);
-
-        glyphCache->setGlyphSizeLimit(fFullAtlasManager->getGlyphSizeLimit());
-        return true;
-    }
-
-    GrRestrictedAtlasManager* onGetRestrictedAtlasManager() override { return fFullAtlasManager; }
-    GrAtlasManager* onGetFullAtlasManager() override { return fFullAtlasManager; }
 
 private:
-    GrAtlasManager* fFullAtlasManager;
-
     typedef GrContext INHERITED;
 };
 
-/**
- * The DDL Context is the one in effect during DDL Recording. It isn't backed by a GrGPU and
- * cannot allocate any GPU resources.
- */
 class SK_API GrDDLContext : public GrContext {
 public:
-    GrDDLContext(GrContextThreadSafeProxy* proxy)
-            : INHERITED(proxy)
-            , fRestrictedAtlasManager(nullptr) {
-    }
-
-    ~GrDDLContext() override {
-        // The GrDDLContext doesn't actually own the fRestrictedAtlasManager so don't delete it
-    }
-
-    void abandonContext() override {
-        SkASSERT(0); // abandoning in a DDL Recorder doesn't make a whole lot of sense
-        INHERITED::abandonContext();
-    }
-
-    void releaseResourcesAndAbandonContext() override {
-        SkASSERT(0); // abandoning in a DDL Recorder doesn't make a whole lot of sense
-        INHERITED::releaseResourcesAndAbandonContext();
-    }
-
-    void freeGpuResources() override {
-        SkASSERT(0); // freeing resources in a DDL Recorder doesn't make a whole lot of sense
-        INHERITED::freeGpuResources();
-    }
+    GrDDLContext(GrContextThreadSafeProxy* proxy) : INHERITED(proxy) {}
 
 protected:
-    bool init(const GrContextOptions& options) override {
-        if (!INHERITED::init(options)) {
-            return false;
-        }
-
-        // DDL TODO: in DDL-mode grab a GrRestrictedAtlasManager from the thread-proxy and
-        // do not add an onFlushCB
-        return true;
-    }
-
-    GrRestrictedAtlasManager* onGetRestrictedAtlasManager() override {
-        return fRestrictedAtlasManager;
-    }
-
-    GrAtlasManager* onGetFullAtlasManager() override {
-        SkASSERT(0);   // the DDL Recorders should never invoke this
-        return nullptr;
-    }
+    // DDL TODO: grab a GrRestrictedAtlasManager from the proxy
 
 private:
-    GrRestrictedAtlasManager* fRestrictedAtlasManager;
-
     typedef GrContext INHERITED;
 };
 
@@ -281,7 +180,7 @@ sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue) {
 }
 
 sk_sp<GrContext> GrContext::MakeMetal(void* device, void* queue, const GrContextOptions& options) {
-    sk_sp<GrContext> context(new GrDirectContext(kMetal_GrBackend));
+    sk_sp<GrContext> context(new GrContext(kMetal_GrBackend));
 
     context->fGpu = GrMtlTrampoline::MakeGpu(context.get(), options, device, queue);
     if (!context->fGpu) {
@@ -321,6 +220,7 @@ GrContext::GrContext(GrBackend backend)
     fResourceProvider = nullptr;
     fProxyProvider = nullptr;
     fGlyphCache = nullptr;
+    fFullAtlasManager = nullptr;
 }
 
 GrContext::GrContext(GrContextThreadSafeProxy* proxy)
@@ -331,6 +231,7 @@ GrContext::GrContext(GrContextThreadSafeProxy* proxy)
     fResourceProvider = nullptr;
     fProxyProvider = nullptr;
     fGlyphCache = nullptr;
+    fFullAtlasManager = nullptr;
 }
 
 bool GrContext::init(const GrContextOptions& options) {
@@ -387,8 +288,26 @@ bool GrContext::init(const GrContextOptions& options) {
     fDrawingManager.reset(new GrDrawingManager(this, prcOptions, atlasTextContextOptions,
                                                &fSingleOwner, options.fSortRenderTargets));
 
+    GrDrawOpAtlas::AllowMultitexturing allowMultitexturing;
+    if (GrContextOptions::Enable::kNo == options.fAllowMultipleGlyphCacheTextures ||
+        // multitexturing supported only if range can represent the index + texcoords fully
+        !(fCaps->shaderCaps()->floatIs32Bits() || fCaps->shaderCaps()->integerSupport())) {
+        allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kNo;
+    } else {
+        allowMultitexturing = GrDrawOpAtlas::AllowMultitexturing::kYes;
+    }
+
     fGlyphCache = new GrGlyphCache;
 
+    // DDL TODO: in DDL-mode grab a GrRestrictedAtlasManager from the thread-proxy and
+    // do not add an onFlushCB
+    fFullAtlasManager = new GrAtlasManager(fProxyProvider, fGlyphCache,
+                                           options.fGlyphCacheTextureMaximumBytes,
+                                           allowMultitexturing);
+    this->contextPriv().addOnFlushCallbackObject(fFullAtlasManager);
+
+    fGlyphCache->setGlyphSizeLimit(fFullAtlasManager->getGlyphSizeLimit());
+
     fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB,
                                              this, this->uniqueID(), SkToBool(fGpu)));
 
@@ -404,6 +323,10 @@ bool GrContext::init(const GrContextOptions& options) {
 GrContext::~GrContext() {
     ASSERT_SINGLE_OWNER
 
+    if (fGpu) {
+        this->flush();
+    }
+
     if (fDrawingManager) {
         fDrawingManager->cleanup();
     }
@@ -416,6 +339,7 @@ GrContext::~GrContext() {
     delete fResourceCache;
     delete fProxyProvider;
     delete fGlyphCache;
+    delete fFullAtlasManager;
 }
 
 sk_sp<GrContextThreadSafeProxy> GrContext::threadSafeProxy() {
@@ -475,6 +399,7 @@ void GrContext::abandonContext() {
     fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
 
     fGlyphCache->freeAll();
+    fFullAtlasManager->freeAll();
     fTextBlobCache->freeAll();
 }
 
@@ -494,6 +419,7 @@ void GrContext::releaseResourcesAndAbandonContext() {
     fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
 
     fGlyphCache->freeAll();
+    fFullAtlasManager->freeAll();
     fTextBlobCache->freeAll();
 }
 
@@ -505,7 +431,10 @@ void GrContext::resetContext(uint32_t state) {
 void GrContext::freeGpuResources() {
     ASSERT_SINGLE_OWNER
 
+    this->flush();
+
     fGlyphCache->freeAll();
+    fFullAtlasManager->freeAll();
 
     fDrawingManager->freeGpuResources();
 
diff --git a/src/gpu/GrContextPriv.h b/src/gpu/GrContextPriv.h
index a8fda09efe..c2e525d9b9 100644
--- a/src/gpu/GrContextPriv.h
+++ b/src/gpu/GrContextPriv.h
@@ -190,14 +190,16 @@ public:
 
     GrGlyphCache* getGlyphCache() { return fContext->fGlyphCache; }
     GrTextBlobCache* getTextBlobCache() { return fContext->fTextBlobCache.get(); }
-
-    GrRestrictedAtlasManager* getRestrictedAtlasManager() {
-        return fContext->onGetRestrictedAtlasManager();
-    }
+    GrRestrictedAtlasManager* getRestrictedAtlasManager() { return fContext->fFullAtlasManager; }
 
     // This accessor should only ever be called by the GrOpFlushState.
     GrAtlasManager* getFullAtlasManager() {
-        return fContext->onGetFullAtlasManager();
+        if (fContext->fResourceProvider) {
+            // Disallow access to the full atlasManager when recording DDLs
+            return fContext->fFullAtlasManager;
+        }
+
+        return nullptr;
     }
 
     void moveOpListsToDDL(SkDeferredDisplayList*);
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index 241bbc2f60..c483a22aac 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -94,10 +94,7 @@ void GrContext::setTextBlobCacheLimit_ForTesting(size_t bytes) {
 }
 
 void GrContext::setTextContextAtlasSizes_ForTesting(const GrDrawOpAtlasConfig* configs) {
-    GrAtlasManager* atlasManager = this->contextPriv().getFullAtlasManager();
-    if (atlasManager) {
-        atlasManager->setAtlasSizes_ForTesting(configs);
-    }
+    fFullAtlasManager->setAtlasSizes_ForTesting(configs);
 }
 
 ///////////////////////////////////////////////////////////////////////////////