chromium/third_party/skia/src/gpu/graphite/Recording.cpp

/*
 * Copyright 2021 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/gpu/graphite/Recording.h"

#include "src/core/SkChecksum.h"
#include "src/gpu/RefCntedCallback.h"
#include "src/gpu/graphite/CommandBuffer.h"
#include "src/gpu/graphite/ContextPriv.h"
#include "src/gpu/graphite/Log.h"
#include "src/gpu/graphite/RecordingPriv.h"
#include "src/gpu/graphite/Resource.h"
#include "src/gpu/graphite/ResourceProvider.h"
#include "src/gpu/graphite/Surface_Graphite.h"
#include "src/gpu/graphite/Texture.h"
#include "src/gpu/graphite/TextureProxy.h"
#include "src/gpu/graphite/task/TaskList.h"

#include <unordered_set>

usingnamespaceskia_private;

namespace skgpu::graphite {

Recording::Recording(uint32_t uniqueID,
                     uint32_t recorderID,
                     std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& nonVolatileLazyProxies,
                     std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& volatileLazyProxies,
                     std::unique_ptr<LazyProxyData> targetProxyData,
                     TArray<sk_sp<RefCntedCallback>>&& finishedProcs)
        : … { … }

Recording::~Recording() { … }

std::size_t Recording::ProxyHash::operator()(const sk_sp<TextureProxy> &proxy) const { … }

Recording::LazyProxyData::LazyProxyData(const TextureInfo& textureInfo) { … }

TextureProxy* Recording::LazyProxyData::lazyProxy() { … }

sk_sp<TextureProxy> Recording::LazyProxyData::refLazyProxy() { … }

bool Recording::LazyProxyData::lazyInstantiate(ResourceProvider* resourceProvider,
                                               sk_sp<Texture> texture) { … }

////////////////////////////////////////////////////////////////////////////////
bool RecordingPriv::hasNonVolatileLazyProxies() const { … }

bool RecordingPriv::instantiateNonVolatileLazyProxies(ResourceProvider* resourceProvider) { … }

bool RecordingPriv::hasVolatileLazyProxies() const { … }

bool RecordingPriv::instantiateVolatileLazyProxies(ResourceProvider* resourceProvider) { … }

void RecordingPriv::deinstantiateVolatileLazyProxies() { … }

void RecordingPriv::setFailureResultForFinishedProcs() { … }

bool RecordingPriv::addCommands(Context* context,
                                CommandBuffer* commandBuffer,
                                Surface* targetSurface,
                                SkIVector targetTranslation) { … }

void RecordingPriv::addResourceRef(sk_sp<Resource> resource) { … }

#if defined(GPU_TEST_UTILS)
bool RecordingPriv::isTargetProxyInstantiated() const {
    return fRecording->fTargetProxyData->lazyProxy()->isInstantiated();
}

int RecordingPriv::numVolatilePromiseImages() const {
    return fRecording->fVolatileLazyProxies.size();
}

int RecordingPriv::numNonVolatilePromiseImages() const {
    return fRecording->fNonVolatileLazyProxies.size();
}

bool RecordingPriv::hasTasks() const {
    return fRecording->fRootTaskList->hasTasks();
}
#endif

} // namespace skgpu::graphite