0

Remove use_stream_video_draw_quad from VideoResourceUpdater ctor

It's always set on android. It's never set anywhere else. The flag is
remnants of old StreamVideoDrawQuad system which no longer exists,
though we still have TextureDrawQuad::is_stream_video that is used on
Android and Windows for minor reasons.

This CL is first step to clean this up.

Bug: 396584155
Change-Id: Idb0ebe3529bfc842b52ec62a0d04e679463c1032
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6270476
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1425778}
This commit is contained in:
Vasiliy Telezhnikov
2025-02-27 08:50:18 -08:00
committed by Chromium LUCI CQ
parent 3a370e4849
commit 877c1b9818
9 changed files with 22 additions and 33 deletions

@ -78,7 +78,6 @@ void CameraVideoFrameRenderer::Initialize() {
video_resource_updater_ = std::make_unique<media::VideoResourceUpdater>(
context_provider_.get(), &client_resource_provider_,
layer_tree_frame_sink_->shared_image_interface(),
/*use_stream_video_draw_quad=*/false,
/*use_gpu_memory_buffer_resources=*/false, max_texture_size);
video_frame_handler_.StartHandlingFrames(/*delegate=*/this);

@ -107,7 +107,6 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
layer_tree_impl()->context_provider(),
layer_tree_impl()->resource_provider(),
layer_tree_impl()->layer_tree_frame_sink()->shared_image_interface(),
settings.use_stream_video_draw_quad,
settings.use_gpu_memory_buffer_resources,
layer_tree_impl()->max_texture_size());
}

@ -57,7 +57,6 @@ class CC_EXPORT LayerTreeSettings {
int gpu_rasterization_msaa_sample_count = -1;
float gpu_rasterization_skewport_target_time_in_seconds = 0.2f;
bool create_low_res_tiling = false;
bool use_stream_video_draw_quad = false;
bool use_gpu_memory_buffer_resources = false;
enum ScrollbarAnimator {

@ -1916,20 +1916,19 @@ class IntersectingMultiplanarVideoQuadPixelTest : public VizPixelTestWithParam {
public:
void SetUp() override {
VizPixelTestWithParam::SetUp();
constexpr bool kUseStreamVideoDrawQuad = false;
constexpr bool kUseGpuMemoryBufferResources = false;
constexpr int kMaxResourceSize = 10000;
video_resource_updater_ = std::make_unique<media::VideoResourceUpdater>(
this->child_context_provider_.get(),
this->child_resource_provider_.get(),
/*shared_image_interface=*/nullptr, kUseStreamVideoDrawQuad,
kUseGpuMemoryBufferResources, kMaxResourceSize);
/*shared_image_interface=*/nullptr, kUseGpuMemoryBufferResources,
kMaxResourceSize);
video_resource_updater2_ = std::make_unique<media::VideoResourceUpdater>(
this->child_context_provider_.get(),
this->child_resource_provider_.get(),
/*shared_image_interface=*/nullptr, kUseStreamVideoDrawQuad,
kUseGpuMemoryBufferResources, kMaxResourceSize);
/*shared_image_interface=*/nullptr, kUseGpuMemoryBufferResources,
kMaxResourceSize);
}
void TearDown() override {
@ -2395,13 +2394,12 @@ class VideoRendererPixelTestBase : public VizPixelTest {
void SetUp() override {
VizPixelTest::SetUp();
constexpr bool kUseStreamVideoDrawQuad = false;
constexpr bool kUseGpuMemoryBufferResources = false;
constexpr int kMaxResourceSize = 10000;
video_resource_updater_ = std::make_unique<media::VideoResourceUpdater>(
child_context_provider_.get(), child_resource_provider_.get(),
/*shared_image_interface=*/nullptr, kUseStreamVideoDrawQuad,
kUseGpuMemoryBufferResources, kMaxResourceSize);
/*shared_image_interface=*/nullptr, kUseGpuMemoryBufferResources,
kMaxResourceSize);
}
void TearDown() override {

@ -79,10 +79,8 @@ gfx::ProtectedVideoType ProtectedVideoTypeFromMetadata(
: gfx::ProtectedVideoType::kSoftwareProtected;
}
VideoFrameResourceType ExternalResourceTypeForHardware(
const VideoFrame& frame,
GLuint target,
bool use_stream_video_draw_quad) {
VideoFrameResourceType ExternalResourceTypeForHardware(const VideoFrame& frame,
GLuint target) {
bool si_prefers_external_sampler =
frame.shared_image()->format().PrefersExternalSampler();
if (si_prefers_external_sampler) {
@ -98,14 +96,17 @@ VideoFrameResourceType ExternalResourceTypeForHardware(
case PIXEL_FORMAT_BGRA:
switch (target) {
case GL_TEXTURE_EXTERNAL_OES:
// `use_stream_video_draw_quad` is set on Android and `dcomp_surface`
// is used on Windows.
#if BUILDFLAG(IS_ANDROID)
return VideoFrameResourceType::STREAM_TEXTURE;
#elif BUILDFLAG(IS_WIN)
// TODO(sunnyps): It's odd to reuse the Android path on Windows. There
// could be other unknown assumptions in other parts of the rendering
// stack about stream video quads. Investigate alternative solutions.
if (use_stream_video_draw_quad || frame.metadata().dcomp_surface)
if (frame.metadata().dcomp_surface) {
return VideoFrameResourceType::STREAM_TEXTURE;
}
[[fallthrough]];
#endif
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE_ARB:
return (format == PIXEL_FORMAT_XRGB)
@ -586,13 +587,11 @@ VideoResourceUpdater::VideoResourceUpdater(
viz::RasterContextProvider* context_provider,
viz::ClientResourceProvider* resource_provider,
scoped_refptr<gpu::SharedImageInterface> shared_image_interface,
bool use_stream_video_draw_quad,
bool use_gpu_memory_buffer_resources,
int max_resource_size)
: context_provider_(context_provider),
shared_image_interface_(std::move(shared_image_interface)),
resource_provider_(resource_provider),
use_stream_video_draw_quad_(use_stream_video_draw_quad),
use_gpu_memory_buffer_resources_(use_gpu_memory_buffer_resources),
max_resource_size_(max_resource_size),
tracing_id_(g_next_video_resource_updater_id.GetNext()) {
@ -895,8 +894,8 @@ VideoFrameExternalResource VideoResourceUpdater::CreateForHardwareFrame(
target = GL_TEXTURE_2D;
}
external_resource.type = ExternalResourceTypeForHardware(
*video_frame, target, use_stream_video_draw_quad_);
external_resource.type =
ExternalResourceTypeForHardware(*video_frame, target);
external_resource.bits_per_channel = video_frame->BitDepth();
if (external_resource.type == VideoFrameResourceType::NONE) {

@ -82,7 +82,6 @@ class MEDIA_EXPORT VideoResourceUpdater
viz::RasterContextProvider* context_provider,
viz::ClientResourceProvider* resource_provider,
scoped_refptr<gpu::SharedImageInterface> shared_image_interface,
bool use_stream_video_draw_quad,
bool use_gpu_memory_buffer_resources,
int max_resource_size);
@ -215,7 +214,6 @@ class MEDIA_EXPORT VideoResourceUpdater
scoped_refptr<gpu::SharedImageInterface> shared_image_interface_;
const raw_ptr<viz::ClientResourceProvider, DanglingUntriaged>
resource_provider_;
const bool use_stream_video_draw_quad_;
const bool use_gpu_memory_buffer_resources_;
const int max_resource_size_;
const int tracing_id_;

@ -76,11 +76,10 @@ class VideoResourceUpdaterTest : public testing::Test {
resource_provider_ = std::make_unique<viz::ClientResourceProvider>();
}
std::unique_ptr<VideoResourceUpdater> CreateUpdaterForHardware(
bool use_stream_video_draw_quad = false) {
std::unique_ptr<VideoResourceUpdater> CreateUpdaterForHardware() {
return std::make_unique<VideoResourceUpdater>(
context_provider_.get(), resource_provider_.get(),
/*shared_image_interface=*/nullptr, use_stream_video_draw_quad,
/*shared_image_interface=*/nullptr,
/*use_gpu_memory_buffer_resources=*/false,
/*max_resource_size=*/10000);
}
@ -89,7 +88,6 @@ class VideoResourceUpdaterTest : public testing::Test {
return std::make_unique<VideoResourceUpdater>(
/*context_provider=*/nullptr, resource_provider_.get(),
shared_image_interface_provider_.GetSharedImageInterface(),
/*use_stream_video_draw_quad=*/false,
/*use_gpu_memory_buffer_resources=*/false, /*max_resource_size=*/10000);
}
@ -745,11 +743,10 @@ TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_SharedImageFormat) {
viz::TransferableResource::SynchronizationType::kGpuCommandsCompleted);
}
#if BUILDFLAG(IS_ANDROID)
TEST_F(VideoResourceUpdaterTest,
CreateForHardwarePlanes_StreamTexture_CopyToNewTexture) {
// Note that |use_stream_video_draw_quad| is true for this test.
std::unique_ptr<VideoResourceUpdater> updater =
CreateUpdaterForHardware(true);
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();
EXPECT_EQ(0u, GetSharedImageCount());
scoped_refptr<VideoFrame> video_frame =
CreateTestStreamTextureHardwareVideoFrame(/*needs_copy=*/false);
@ -771,6 +768,7 @@ TEST_F(VideoResourceUpdaterTest,
EXPECT_EQ((GLenum)GL_TEXTURE_2D, resource.resource.texture_target());
EXPECT_EQ(1u, GetSharedImageCount());
}
#endif
TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_TextureQuad) {
std::unique_ptr<VideoResourceUpdater> updater = CreateUpdaterForHardware();

@ -52,7 +52,7 @@ void VideoFrameResourceProvider::Initialize(
resource_updater_ = std::make_unique<media::VideoResourceUpdater>(
media_context_provider, resource_provider_.get(),
std::move(shared_image_interface), settings_.use_stream_video_draw_quad,
std::move(shared_image_interface),
settings_.use_gpu_memory_buffer_resources, max_texture_size);
}

@ -465,7 +465,6 @@ cc::LayerTreeSettings GenerateLayerTreeSettings(
base::SysInfo::IsLowEndDevice() && !IsSmallScreen(screen_size) &&
!platform->IsSynchronousCompositingEnabledForAndroidWebView();
settings.use_stream_video_draw_quad = true;
settings.using_synchronous_renderer_compositor = use_synchronous_compositor;
if (use_synchronous_compositor) {
// Root frame in Android WebView uses system scrollbars, so make ours