components/viz/service/display_embedder/skia_output_surface_dependency_impl.cc

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

#include "components/viz/service/display_embedder/skia_output_surface_dependency_impl.h"

#include "base/threading/thread_task_runner_handle.h"
#include "build/build_config.h"
#include "components/viz/service/gl/gpu_service_impl.h"
#include "gpu/command_buffer/service/scheduler.h"
#include "gpu/ipc/service/image_transport_surface.h"
#include "ui/gl/init/gl_factory.h"

namespace viz {

SkiaOutputSurfaceDependencyImpl::SkiaOutputSurfaceDependencyImpl(
    GpuServiceImpl* gpu_service_impl,
    gpu::SurfaceHandle surface_handle)
    : gpu_service_impl_(gpu_service_impl),
      surface_handle_(surface_handle),
      client_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}

SkiaOutputSurfaceDependencyImpl::~SkiaOutputSurfaceDependencyImpl() = default;

void SkiaOutputSurfaceDependencyImpl::ScheduleGpuTask(
    base::OnceClosure task,
    std::vector<gpu::SyncToken> sync_tokens) {
  gpu_service_impl_->scheduler()->ScheduleTask(
      gpu::Scheduler::Task(gpu_service_impl_->skia_output_surface_sequence_id(),
                           std::move(task), std::move(sync_tokens)));
}

bool SkiaOutputSurfaceDependencyImpl::IsUsingVulkan() {
  return gpu_service_impl_->is_using_vulkan();
}

gpu::SharedImageManager*
SkiaOutputSurfaceDependencyImpl::GetSharedImageManager() {
  return gpu_service_impl_->shared_image_manager();
}

gpu::SyncPointManager* SkiaOutputSurfaceDependencyImpl::GetSyncPointManager() {
  return gpu_service_impl_->sync_point_manager();
}

const gpu::GpuDriverBugWorkarounds&
SkiaOutputSurfaceDependencyImpl::GetGpuDriverBugWorkarounds() {
  return gpu_service_impl_->gpu_channel_manager()->gpu_driver_bug_workarounds();
}

scoped_refptr<gpu::SharedContextState>
SkiaOutputSurfaceDependencyImpl::GetSharedContextState() {
  return gpu_service_impl_->GetContextState();
}

gpu::raster::GrShaderCache*
SkiaOutputSurfaceDependencyImpl::GetGrShaderCache() {
  return gpu_service_impl_->gr_shader_cache();
}

VulkanContextProvider*
SkiaOutputSurfaceDependencyImpl::GetVulkanContextProvider() {
  return gpu_service_impl_->vulkan_context_provider();
}

const gpu::GpuPreferences&
SkiaOutputSurfaceDependencyImpl::GetGpuPreferences() {
  return gpu_service_impl_->gpu_preferences();
}

gpu::SequenceId SkiaOutputSurfaceDependencyImpl::GetSequenceId() {
  return gpu_service_impl_->skia_output_surface_sequence_id();
}

const gpu::GpuFeatureInfo&
SkiaOutputSurfaceDependencyImpl::GetGpuFeatureInfo() {
  return gpu_service_impl_->gpu_feature_info();
}

gpu::MailboxManager* SkiaOutputSurfaceDependencyImpl::GetMailboxManager() {
  return gpu_service_impl_->mailbox_manager();
}

bool SkiaOutputSurfaceDependencyImpl::IsOffscreen() {
  return surface_handle_ == gpu::kNullSurfaceHandle;
}

gpu::SurfaceHandle SkiaOutputSurfaceDependencyImpl::GetSurfaceHandle() {
  return surface_handle_;
}

scoped_refptr<gl::GLSurface> SkiaOutputSurfaceDependencyImpl::CreateGLSurface(
    base::WeakPtr<gpu::ImageTransportSurfaceDelegate> stub) {
  if (IsOffscreen()) {
    return gl::init::CreateOffscreenGLSurface(gfx::Size());
  } else {
    return gpu::ImageTransportSurface::CreateNativeSurface(
        stub, surface_handle_, gl::GLSurfaceFormat());
  }
}

void SkiaOutputSurfaceDependencyImpl::PostTaskToClientThread(
    base::OnceClosure closure) {
  client_thread_task_runner_->PostTask(FROM_HERE, std::move(closure));
}

void SkiaOutputSurfaceDependencyImpl::ScheduleGrContextCleanup() {
  gpu_service_impl_->gpu_channel_manager()->ScheduleGrContextCleanup();
}

#if defined(OS_WIN)
void SkiaOutputSurfaceDependencyImpl::DidCreateAcceleratedSurfaceChildWindow(
    gpu::SurfaceHandle parent_window,
    gpu::SurfaceHandle child_window) {
  gpu_service_impl_->SendCreatedChildWindow(parent_window, child_window);
}
#endif

}  // namespace viz