Add SkCharacterization creation helper to GrContextThreadSafeProxy (take 2)

TBR=bsalomon@google.com
Change-Id: Id96d4fdbb6889065f10a4a7e0c22a03ad9aa5fef
Reviewed-on: https://skia-review.googlesource.com/107000
Reviewed-by: Robert Phillips <robertphillips@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

4 files changed, 112 insertions, 4 deletions

diff --git a/include/gpu/GrBackendSurface.h b/include/gpu/GrBackendSurface.h
index ffe422d0a7..c8072c9bfb 100644
--- a/include/gpu/GrBackendSurface.h
+++ b/include/gpu/GrBackendSurface.h
@@ -16,6 +16,69 @@
 #include "vk/GrVkTypes.h"
 #endif
 
+class SK_API GrBackendFormat {
+public:
+    // Creates an invalid backend format.
+    GrBackendFormat() : fValid(false) {}
+
+    static GrBackendFormat MakeGL(GrGLenum format, GrGLenum target) {
+        return GrBackendFormat(format, target);
+    }
+
+#ifdef SK_VULKAN
+    static GrBackendFormat MakeVK(VkFormat format) {
+        return GrBackendFormat(format);
+    }
+#endif
+
+    static GrBackendFormat MakeMock(GrPixelConfig config) {
+        return GrBackendFormat(config);
+    }
+
+    GrBackend backend() const {return fBackend; }
+
+    // If the backend API is GL, these return a pointer to the format and target. Otherwise
+    // it returns nullptr.
+    const GrGLenum* getGLFormat() const;
+    const GrGLenum* getGLTarget() const;
+
+#ifdef SK_VULKAN
+    // If the backend API is Vulkan, this returns a pointer to a VkFormat. Otherwise
+    // it returns nullptr
+    const VkFormat* getVkFormat() const;
+#endif
+
+    // If the backend API is Mock, this returns a pointer to a GrPixelConfig. Otherwise
+    // it returns nullptr.
+    const GrPixelConfig* getMockFormat() const;
+
+    // Returns true if the backend format has been initialized.
+    bool isValid() const { return fValid; }
+
+private:
+    GrBackendFormat(GrGLenum format, GrGLenum target);
+
+#ifdef SK_VULKAN
+    GrBackendFormat(const VkFormat vkFormat);
+#endif
+
+    GrBackendFormat(const GrPixelConfig config);
+
+    GrBackend fBackend;
+    bool      fValid;
+
+    union {
+        struct {
+            GrGLenum fTarget; // GL_TEXTURE_2D, GL_TEXTURE_EXTERNAL or GL_TEXTURE_RECTANGLE
+            GrGLenum fFormat; // the sized, internal format of the GL resource
+        } fGL;
+#ifdef SK_VULKAN
+        VkFormat      fVkFormat;
+#endif
+        GrPixelConfig fMockFormat;
+    };
+};
+
 class SK_API GrBackendTexture {
 public:
     // Creates an invalid backend texture.
diff --git a/include/gpu/GrCaps.h b/include/gpu/GrCaps.h
index 0f03f162f0..1b81b18fcb 100644
--- a/include/gpu/GrCaps.h
+++ b/include/gpu/GrCaps.h
@@ -15,6 +15,7 @@
 #include "SkRefCnt.h"
 #include "SkString.h"
 
+class GrBackendFormat;
 class GrBackendRenderTarget;
 class GrBackendTexture;
 struct GrContextOptions;
@@ -200,7 +201,7 @@ public:
     bool validateSurfaceDesc(const GrSurfaceDesc&, GrMipMapped) const;
 
     /**
-     * Returns true if the GrBackendTexutre can we used with the supplied SkColorType. If it is
+     * Returns true if the GrBackendTexture can be used with the supplied SkColorType. If it is
      * compatible, the passed in GrPixelConfig will be set to a config that matches the backend
      * format and requested SkColorType.
      */
@@ -209,6 +210,12 @@ public:
     virtual bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType,
                                              GrPixelConfig*) const = 0;
 
+    // TODO: replace validateBackendTexture and validateBackendRenderTarget with calls to
+    // getConfigFromBackendFormat?
+    // TODO: it seems like we could pass the full SkImageInfo and validate its colorSpace too
+    virtual bool getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct,
+                                            GrPixelConfig*) const = 0;
+
 protected:
     /** Subclasses must call this at the end of their constructors in order to apply caps
         overrides requested by the client. Note that overrides will only reduce the caps never
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index cb68bb9128..4d937c727e 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -17,6 +17,7 @@
 #include "GrContextOptions.h"
 
 class GrAtlasGlyphCache;
+class GrBackendFormat;
 class GrBackendSemaphore;
 class GrContextPriv;
 class GrContextThreadSafeProxy;
@@ -36,17 +37,18 @@ class GrResourceCache;
 class GrResourceProvider;
 class GrSamplerState;
 class GrSurfaceProxy;
+class GrSwizzle;
 class GrTextBlobCache;
 class GrTextContext;
 class GrTextureProxy;
 class GrVertexBuffer;
 struct GrVkBackendContext;
-class GrSwizzle;
-class SkTraceMemoryDump;
 
 class SkImage;
+class SkSurfaceCharacterization;
 class SkSurfaceProps;
 class SkTaskGroup;
+class SkTraceMemoryDump;
 
 class SK_API GrContext : public SkRefCnt {
 public:
@@ -435,6 +437,41 @@ class GrContextThreadSafeProxy : public SkRefCnt {
 public:
     bool matches(GrContext* context) const { return context->uniqueID() == fContextUniqueID; }
 
+    /**
+     *  Create a surface characterization for a DDL that will be replayed into the GrContext
+     *  that created this proxy. On failure the resulting characterization will be invalid (i.e.,
+     *  "!c.isValid()").
+     *
+     *  @param cacheMaxResourceBytes The max resource bytes limit that will be in effect when the
+     *                               DDL created with this characterization is replayed.
+     *                               Note: the contract here is that the DDL will be created as
+     *                               if it had a full 'cacheMaxResourceBytes' to use. If replayed
+     *                               into a GrContext that already has locked GPU memory, the
+     *                               replay can exceed the budget. To rephrase, all resource
+     *                               allocation decisions are made at record time and at playback
+     *                               time the budget limits will be ignored.
+     *  @param ii                    The image info specifying properties of the SkSurface that
+     *                               the DDL created with this characterization will be replayed
+     *                               into.
+     *                               Note: Ganesh doesn't make use of the SkImageInfo's alphaType
+     *  @param backendFormat         Information about the format of the GPU surface that will
+     *                               back the SkSurface upon replay
+     *  @param sampleCount           The sample count of the SkSurface that the DDL created with
+     *                               this characterization will be replayed into
+     *  @param origin                The origin of the SkSurface that the DDL created with this
+     *                               characterization will be replayed into
+     *  @param surfaceProps          The surface properties of the SkSurface that the DDL created
+     *                               with this characterization will be replayed into
+     *  @param isMipMapped           Will the surface the DDL will be replayed into have space
+     *                               allocated for mipmaps?
+     */
+    SkSurfaceCharacterization createCharacterization(
+                                  size_t cacheMaxResourceBytes,
+                                  const SkImageInfo& ii, const GrBackendFormat& backendFormat,
+                                  int sampleCount, GrSurfaceOrigin origin,
+                                  const SkSurfaceProps& surfaceProps,
+                                  bool isMipMapped);
+
 private:
     // DDL TODO: need to add unit tests for backend & maybe options
     GrContextThreadSafeProxy(sk_sp<const GrCaps> caps,
diff --git a/include/gpu/mock/GrMockTypes.h b/include/gpu/mock/GrMockTypes.h
index 0954c5eadc..49601cb55e 100644
--- a/include/gpu/mock/GrMockTypes.h
+++ b/include/gpu/mock/GrMockTypes.h
@@ -12,7 +12,8 @@
 #include "../private/GrTypesPriv.h"
 
 struct GrMockTextureInfo {
-    int fID;
+    GrPixelConfig fConfig;
+    int           fID;
 };
 
 /**