shared_image_backing.cc | Explore in Territory

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gpu/command_buffer/service/shared_image/shared_image_backing.h"

#include "base/not_fatal_until.h"
#include "base/notreached.h"
#include "base/ranges/algorithm.h"
#include "base/trace_event/process_memory_dump.h"
#include "build/build_config.h"
#include "components/viz/common/resources/shared_image_format_utils.h"
#include "gpu/command_buffer/common/mailbox.h"
#include "gpu/command_buffer/common/shared_image_trace_utils.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/command_buffer/service/memory_tracking.h"
#include "gpu/command_buffer/service/shared_context_state.h"
#include "gpu/command_buffer/service/shared_image/shared_image_factory.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "third_party/skia/include/core/SkColorSpace.h"

#if BUILDFLAG(IS_WIN)
#include "ui/gfx/win/d3d_shared_fence.h"
#endif

namespace gpu {
namespace {

const char* BackingTypeToString(SharedImageBackingType type) { … }

}  // namespace

SharedImageBacking::SharedImageBacking(
    const Mailbox& mailbox,
    viz::SharedImageFormat format,
    const gfx::Size& size,
    const gfx::ColorSpace& color_space,
    GrSurfaceOrigin surface_origin,
    SkAlphaType alpha_type,
    SharedImageUsageSet usage,
    std::string debug_label,
    size_t estimated_size,
    bool is_thread_safe,
    std::optional<gfx::BufferUsage> buffer_usage)
    : … { … }

SharedImageBacking::~SharedImageBacking() = default;

void SharedImageBacking::OnContextLost() { … }

SkImageInfo SharedImageBacking::AsSkImageInfo(int plane_index) const { … }

bool SharedImageBacking::CopyToGpuMemoryBuffer() { … }

void SharedImageBacking::CopyToGpuMemoryBufferAsync(
    base::OnceCallback<void(bool)> callback) { … }

void SharedImageBacking::Update(std::unique_ptr<gfx::GpuFence> in_fence) { … }

bool SharedImageBacking::UploadFromMemory(
    const std::vector<SkPixmap>& pixmaps) { … }

bool SharedImageBacking::ReadbackToMemory(
    const std::vector<SkPixmap>& pixmaps) { … }

void SharedImageBacking::ReadbackToMemoryAsync(
    const std::vector<SkPixmap>& pixmaps,
    base::OnceCallback<void(bool)> callback) { … }

bool SharedImageBacking::PresentSwapChain() { … }

base::trace_event::MemoryAllocatorDump* SharedImageBacking::OnMemoryDump(
    const std::string& dump_name,
    base::trace_event::MemoryAllocatorDumpGuid client_guid,
    base::trace_event::ProcessMemoryDump* pmd,
    uint64_t client_tracing_id) { … }

std::unique_ptr<GLTextureImageRepresentation>
SharedImageBacking::ProduceGLTexture(SharedImageManager* manager,
                                     MemoryTypeTracker* tracker) { … }

std::unique_ptr<GLTexturePassthroughImageRepresentation>
SharedImageBacking::ProduceGLTexturePassthrough(SharedImageManager* manager,
                                                MemoryTypeTracker* tracker) { … }

std::unique_ptr<SkiaImageRepresentation> SharedImageBacking::ProduceSkia(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    scoped_refptr<SharedContextState> context_state) { … }

std::unique_ptr<SkiaGaneshImageRepresentation>
SharedImageBacking::ProduceSkiaGanesh(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    scoped_refptr<SharedContextState> context_state) { … }

std::unique_ptr<SkiaGraphiteImageRepresentation>
SharedImageBacking::ProduceSkiaGraphite(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    scoped_refptr<SharedContextState> context_state) { … }

std::unique_ptr<DawnImageRepresentation> SharedImageBacking::ProduceDawn(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    const wgpu::Device& device,
    wgpu::BackendType backend_type,
    std::vector<wgpu::TextureFormat> view_formats,
    scoped_refptr<SharedContextState> context_state) { … }

std::unique_ptr<OverlayImageRepresentation> SharedImageBacking::ProduceOverlay(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker) { … }

std::unique_ptr<MemoryImageRepresentation> SharedImageBacking::ProduceMemory(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker) { … }

std::unique_ptr<RasterImageRepresentation> SharedImageBacking::ProduceRaster(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker) { … }

std::unique_ptr<VideoImageRepresentation> SharedImageBacking::ProduceVideo(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    VideoDevice device) { … }

#if BUILDFLAG(ENABLE_VULKAN)
std::unique_ptr<VulkanImageRepresentation> SharedImageBacking::ProduceVulkan(
    SharedImageManager* manager,
    MemoryTypeTracker* tracker,
    gpu::VulkanDeviceQueue* vulkan_device_queue,
    gpu::VulkanImplementation& vulkan_impl,
    bool needs_detiling) { … }
#endif

#if BUILDFLAG(IS_ANDROID)
std::unique_ptr<LegacyOverlayImageRepresentation>
SharedImageBacking::ProduceLegacyOverlay(SharedImageManager* manager,
                                         MemoryTypeTracker* tracker) {
  return nullptr;
}
#endif

#if BUILDFLAG(IS_WIN)
void SharedImageBacking::UpdateExternalFence(
    scoped_refptr<gfx::D3DSharedFence> external_fence) {
  NOTIMPLEMENTED_LOG_ONCE();
}
#endif

void SharedImageBacking::UpdateEstimatedSize(size_t estimated_size_bytes) { … }

void SharedImageBacking::SetNotRefCounted() { … }

void SharedImageBacking::AddRef(SharedImageRepresentation* representation) { … }

void SharedImageBacking::ReleaseRef(SharedImageRepresentation* representation) { … }

const MemoryTracker* SharedImageBacking::GetMemoryTracker() const { … }

void SharedImageBacking::RegisterImageFactory(SharedImageFactory* factory) { … }

void SharedImageBacking::UnregisterImageFactory() { … }

const char* SharedImageBacking::GetName() const { … }

bool SharedImageBacking::HasAnyRefs() const { … }

void SharedImageBacking::OnReadSucceeded() { … }

void SharedImageBacking::OnWriteSucceeded() { … }

size_t SharedImageBacking::GetEstimatedSize() const { … }

size_t SharedImageBacking::GetEstimatedSizeForMemoryDump() const { … }

bool SharedImageBacking::have_context() const { … }

SharedImageBacking::AutoLock::AutoLock(
    const SharedImageBacking* shared_image_backing)
    : … { … }

SharedImageBacking::AutoLock::~AutoLock() = default;

base::Lock* SharedImageBacking::AutoLock::InitializeLock(
    const SharedImageBacking* shared_image_backing) { … }

ClearTrackingSharedImageBacking::ClearTrackingSharedImageBacking(
    const Mailbox& mailbox,
    viz::SharedImageFormat format,
    const gfx::Size& size,
    const gfx::ColorSpace& color_space,
    GrSurfaceOrigin surface_origin,
    SkAlphaType alpha_type,
    gpu::SharedImageUsageSet usage,
    std::string debug_label,
    size_t estimated_size,
    bool is_thread_safe,
    std::optional<gfx::BufferUsage> buffer_usage)
    : … { … }

gfx::Rect ClearTrackingSharedImageBacking::ClearedRect() const { … }

void ClearTrackingSharedImageBacking::SetClearedRect(
    const gfx::Rect& cleared_rect) { … }

gfx::Rect ClearTrackingSharedImageBacking::ClearedRectInternal() const { … }

void ClearTrackingSharedImageBacking::SetClearedRectInternal(
    const gfx::Rect& cleared_rect) { … }

scoped_refptr<gfx::NativePixmap> SharedImageBacking::GetNativePixmap() { … }

gfx::GpuMemoryBufferHandle SharedImageBacking::GetGpuMemoryBufferHandle() { … }

bool SharedImageBacking::IsPurgeable() const { … }

bool SharedImageBacking::IsImportedFromExo() { … }

}  // namespace gpu
chromium/gpu/command_buffer/service/shared_image/shared_image_backing.cc
