/*

 * Copyright 2019 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#ifndef GrContextThreadSafeProxy_DEFINED

#define GrContextThreadSafeProxy_DEFINED

#include "include/core/SkRefCnt.h"

#if SK_SUPPORT_GPU

#include "include/core/SkImageInfo.h"

#include "include/gpu/GrContextOptions.h"

#include "include/gpu/GrTypes.h"

#include <atomic>

class GrBackendFormat;

class GrCaps;

class GrContextThreadSafeProxyPriv;

class GrTextBlobCache;

class GrThreadSafeCache;

class GrThreadSafePipelineBuilder;

class SkSurfaceCharacterization;

class SkSurfaceProps;

/**

 * Can be used to perform actions related to the generating GrContext in a thread safe manner. The

 * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.

 */

class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {

public:

    ~GrContextThreadSafeProxy();

    /**

     *  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?

     *  @param willUseGLFBO0                   Will the surface the DDL will be replayed into be

     *                                         backed by GL FBO 0. This flag is only valid if using

     *                                         an GL backend.

     *  @param isTextureable                   Will the surface be able to act as a texture?

     *  @param isProtected                     Will the (Vulkan) surface be DRM protected?

     *  @param vkRTSupportsInputAttachment     Can the vulkan surface be used as in input

                                               attachment?

     *  @param forVulkanSecondaryCommandBuffer Will the surface be wrapping a vulkan secondary

     *                                         command buffer via a GrVkSecondaryCBDrawContext? If

     *                                         this is true then the following is required:

     *                                         isTexureable = false

     *                                         isMipMapped = false

     *                                         willUseGLFBO0 = false

     *                                         vkRTSupportsInputAttachment = false

     */

    SkSurfaceCharacterization createCharacterization(

                                  size_t cacheMaxResourceBytes,

                                  const SkImageInfo& ii,

                                  const GrBackendFormat& backendFormat,

                                  int sampleCount,

                                  GrSurfaceOrigin origin,

                                  const SkSurfaceProps& surfaceProps,

                                  bool isMipMapped,

                                  bool willUseGLFBO0 = false,

                                  bool isTextureable = true,

                                  GrProtected isProtected = GrProtected::kNo,

                                  bool vkRTSupportsInputAttachment = false,

                                  bool forVulkanSecondaryCommandBuffer = false);

    /*

     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.

     * It is guaranteed that this backend format will be the one used by the following

     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.

     *

     * The caller should check that the returned format is valid.

     */

    GrBackendFormat defaultBackendFormat(SkColorType ct, GrRenderable renderable) const;

    /**

     * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is

     * guaranteed to match the backend format used by the following

     * createCompressedBackendTexture methods that take a CompressionType.

     *

     * The caller should check that the returned format is valid.

     */

    GrBackendFormat compressedBackendFormat(SkImage::CompressionType c) const;

    bool isValid() const { return nullptr != fCaps; }

    bool operator==(const GrContextThreadSafeProxy& that) const {

        // Each GrContext should only ever have a single thread-safe proxy.

        SkASSERT((this == &that) == (this->fContextID == that.fContextID));

        return this == &that;

    }

    bool operator!=(const GrContextThreadSafeProxy& that) const { return !(*this == that); }

    // Provides access to functions that aren't part of the public API.

    GrContextThreadSafeProxyPriv priv();

    const GrContextThreadSafeProxyPriv priv() const;  // NOLINT(readability-const-return-type)

private:

    friend class GrContextThreadSafeProxyPriv; // for ctor and hidden methods

    // DDL TODO: need to add unit tests for backend & maybe options

    GrContextThreadSafeProxy(GrBackendApi, const GrContextOptions&);

    void abandonContext();

    bool abandoned() const;

    // TODO: This should be part of the constructor but right now we have a chicken-and-egg problem

    // with GrContext where we get the caps by creating a GPU which requires a context (see the

    // `init` method on GrContext_Base).

    void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);

    const GrBackendApi                      fBackend;

    const GrContextOptions                  fOptions;

    const uint32_t                          fContextID;

    sk_sp<const GrCaps>                     fCaps;

    std::unique_ptr<GrTextBlobCache>        fTextBlobCache;

    std::unique_ptr<GrThreadSafeCache>      fThreadSafeCache;

    sk_sp<GrThreadSafePipelineBuilder>      fPipelineBuilder;

    std::atomic<bool>                       fAbandoned{false};

};

#else // !SK_SUPPORT_GPU

class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};

#endif

#endif