GrContextThreadSafeProxy.h

Go to the documentation of this file.

/*
 * 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 defined(SK_GANESH)
 
#include "include/core/SkImageInfo.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrTypes.h"
 
#include <atomic>
 
class GrBackendFormat;
class GrCaps;
class GrContextThreadSafeProxyPriv;
class GrSurfaceCharacterization;
class GrThreadSafeCache;
class GrThreadSafePipelineBuilder;
class SkSurfaceProps;
enum class SkTextureCompressionType;
 
namespace sktext::gpu { class TextBlobRedrawCoordinator; }
 
class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {
public:
    ~GrContextThreadSafeProxy();
 
    GrSurfaceCharacterization 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 GrSurfaceCharacterization-based createBackendTexture methods.
     *
     * The caller should check that the returned format is valid.
     */
    GrBackendFormat defaultBackendFormat(SkColorType ct, GrRenderable renderable) const;
 
    GrBackendFormat compressedBackendFormat(SkTextureCompressionType c) const;
 
    int maxSurfaceSampleCountForColorType(SkColorType colorType) 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<sktext::gpu::TextBlobRedrawCoordinator> fTextBlobRedrawCoordinator;
    std::unique_ptr<GrThreadSafeCache>                      fThreadSafeCache;
    sk_sp<GrThreadSafePipelineBuilder>                      fPipelineBuilder;
    std::atomic<bool>                                       fAbandoned{false};
};
 
#else // !defined(SK_GANESH)
class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};
#endif
 
#endif