Revert "Revert "Separate creation time & flush time behavior in GrDrawOpAtlas (take 2)""

This reverts commit 84d823a5e2a03b09f7db4964218b9e04e821c878.

Reason for revert: The DFT diffs don't repro on Windows so I'm chalking it up to minor device differences

Original change's description:
> Revert "Separate creation time & flush time behavior in GrDrawOpAtlas (take 2)"
> 
> This reverts commit 96165ebeaa36a2aae0eedaf12d81f53d3caf999a.
> 
> Reason for revert: DFT GMs w/ LCD text are slightly different
> 
> Original change's description:
> > Separate creation time & flush time behavior in GrDrawOpAtlas (take 2)
> > 
> > This CL clarifies what is going on in the GrDrawOpAtlas and GrAtlasGlyphCache.
> > 
> > For the GrDrawOpAtlas:
> >   At creation time all the allowed pages are created (with their backing GrTextureProxies) but they aren't instantiated.
> > 
> >   The GrDrawOpAtlas::instantiate call is called in preFlushCB and allocates any pages known to be needed at the start of flush
> > 
> >   GrDrawOpAtlas::addToAtlas is called at flush time and, if a new page is activated, will instantiated it at that time.
> > 
> >   During compaction, an unused page will be deInstantiated but its Plots and backing GrTextureProxy will remain alive.
> > 
> > The GrAtlasGlyphCache reflects the changes to the GrDrawOpAtlas
> >   It now carries a GrProxyProvider for when it needs to create an atlas
> >   It passes in a GrResourceProvider* at flush time to allow instantiation.
> > 
> >   It does not, yet, allocate that GrDrawOpAtlases it might ever require.
> > 
> > Change-Id: Ie9b64b13e261b01ee14be09fbf7e17841b7781dc
> > Reviewed-on: https://skia-review.googlesource.com/109749
> > Reviewed-by: Jim Van Verth <jvanverth@google.com>
> > Commit-Queue: Robert Phillips <robertphillips@google.com>
> 
> TBR=jvanverth@google.com,robertphillips@google.com
> 
> Change-Id: I62efc61c8394477e54d6e79fa2f65180c91a4515
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://skia-review.googlesource.com/110220
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> Commit-Queue: Robert Phillips <robertphillips@google.com>

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

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

1 files changed, 132 insertions, 0 deletions

diff --git a/tests/DrawOpAtlasTest.cpp b/tests/DrawOpAtlasTest.cpp
new file mode 100644
index 0000000000..a34618e38f
--- /dev/null
+++ b/tests/DrawOpAtlasTest.cpp
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkTypes.h"
+
+#if SK_SUPPORT_GPU
+
+#include "GrContextPriv.h"
+#include "Test.h"
+#include "text/GrAtlasGlyphCache.h"
+
+static const int kNumPlots = 2;
+static const int kPlotSize = 32;
+static const int kAtlasSize = kNumPlots * kPlotSize;
+
+int GrDrawOpAtlas::numAllocated_TestingOnly() const {
+    int count = 0;
+    for (uint32_t i = 0; i < this->maxPages(); ++i) {
+        if (fProxies[i]->priv().isInstantiated()) {
+            ++count;
+        }
+    }
+
+    return count;
+}
+
+void EvictionFunc(GrDrawOpAtlas::AtlasID atlasID, void*) {
+    SkASSERT(0); // The unit test shouldn't exercise this code path
+}
+
+static void check(skiatest::Reporter* r, GrDrawOpAtlas* atlas,
+                  uint32_t expectedActive, uint32_t expectedMax, int expectedAlloced) {
+    REPORTER_ASSERT(r, expectedActive == atlas->numActivePages());
+    REPORTER_ASSERT(r, expectedMax == atlas->maxPages());
+    REPORTER_ASSERT(r, expectedAlloced == atlas->numAllocated_TestingOnly());
+}
+
+class TestingUploadTarget : public GrDeferredUploadTarget {
+public:
+    TestingUploadTarget() { }
+
+    const GrTokenTracker* tokenTracker() final {
+        return &fTokenTracker;
+    }
+
+    GrDeferredUploadToken addInlineUpload(GrDeferredTextureUploadFn&&) final {
+        SkASSERT(0); // this test shouldn't invoke this code path
+        return fTokenTracker.nextDrawToken();
+    }
+
+    virtual GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&& upload) final {
+        return fTokenTracker.nextTokenToFlush();
+    }
+
+    void issueDrawToken() { fTokenTracker.issueDrawToken(); }
+    void flushToken() { fTokenTracker.flushToken(); }
+
+private:
+    GrTokenTracker fTokenTracker;
+
+    typedef GrDeferredUploadTarget INHERITED;
+};
+
+static bool fill_plot(GrDrawOpAtlas* atlas,
+                      GrResourceProvider* resourceProvider,
+                      GrDeferredUploadTarget* target,
+                      GrDrawOpAtlas::AtlasID* atlasID,
+                      int alpha) {
+    SkImageInfo ii = SkImageInfo::MakeA8(kPlotSize, kPlotSize);
+
+    SkBitmap data;
+    data.allocPixels(ii);
+    data.eraseARGB(alpha, 0, 0, 0);
+
+    SkIPoint16 loc;
+    bool result = atlas->addToAtlas(resourceProvider, atlasID, target, kPlotSize, kPlotSize,
+                                    data.getAddr(0, 0), &loc);
+    return result;
+}
+
+
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DrawOpAtlas, reporter, ctxInfo) {
+    auto context = ctxInfo.grContext();
+    auto proxyProvider = context->contextPriv().proxyProvider();
+    auto resourceProvider = context->contextPriv().resourceProvider();
+    auto drawingManager = context->contextPriv().drawingManager();
+
+    GrOnFlushResourceProvider onFlushResourceProvider(drawingManager);
+    TestingUploadTarget uploadTarget;
+
+    std::unique_ptr<GrDrawOpAtlas> atlas = GrDrawOpAtlas::Make(
+                                                proxyProvider,
+                                                kAlpha_8_GrPixelConfig,
+                                                kAtlasSize, kAtlasSize,
+                                                kNumPlots, kNumPlots,
+                                                GrDrawOpAtlas::AllowMultitexturing::kYes,
+                                                EvictionFunc, nullptr);
+    check(reporter, atlas.get(), 0, 4, 0);
+
+    // Fill up the first level
+    GrDrawOpAtlas::AtlasID atlasIDs[kNumPlots * kNumPlots];
+    for (int i = 0; i < kNumPlots * kNumPlots; ++i) {
+        bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasIDs[i], i*32);
+        REPORTER_ASSERT(reporter, result);
+        check(reporter, atlas.get(), 1, 4, 1);
+    }
+
+    atlas->instantiate(&onFlushResourceProvider);
+    check(reporter, atlas.get(), 1, 4, 1);
+
+    // Force allocation of a second level
+    GrDrawOpAtlas::AtlasID atlasID;
+    bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasID, 4*32);
+    REPORTER_ASSERT(reporter, result);
+    check(reporter, atlas.get(), 2, 4, 2);
+
+    // Simulate a lot of draws using only the first plot. The last texture should be compacted.
+    for (int i = 0; i < 512; ++i) {
+        atlas->setLastUseToken(atlasIDs[0], uploadTarget.tokenTracker()->nextDrawToken());
+        uploadTarget.issueDrawToken();
+        uploadTarget.flushToken();
+        atlas->compact(uploadTarget.tokenTracker()->nextTokenToFlush());
+    }
+
+    check(reporter, atlas.get(), 1, 4, 1);
+}
+
+#endif