Merge branch 'rawhide' into epel8

- fix the build order, chrome_feed_response_metadata.pb.h file not found

chromium-112-check-passthrough-command-decoder.patch

@@ -0,0 +1,71 @@
+From 041cb248e818823caaaabc67db92b16499d0416d Mon Sep 17 00:00:00 2001
+From: Vasiliy Telezhnikov <vasilyt@chromium.org>
+Date: Thu, 02 Feb 2023 15:42:28 +0000
+Subject: [PATCH] CHECK that passthrough command decoder is used on launched platforms
+
+This CL adds enforces that validating command decoder is not used on
+platforms where passthrough is fully launched. We still allow to use it
+by tests on linux
+
+Bug: 1406585
+Change-Id: Id6bc1d748fdf9c953dde76c8d4b5f59ddef60857
+Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4212134
+Reviewed-by: Kyle Charbonneau <kylechar@chromium.org>
+Commit-Queue: Vasiliy Telezhnikov <vasilyt@chromium.org>
+Cr-Commit-Position: refs/heads/main@{#1100440}
+---
+
+diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
+index eb710696..b22dffb 100644
+--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
++++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
+@@ -3447,7 +3447,13 @@
+                                            outputter, group);
+   }
+ 
++// Allow linux to run fuzzers.
++#if BUILDFLAG(ENABLE_VALIDATING_COMMAND_DECODER) || BUILDFLAG(IS_LINUX)
+   return new GLES2DecoderImpl(client, command_buffer_service, outputter, group);
++#else
++  LOG(FATAL) << "Validating command decoder is not supported.";
++  return nullptr;
++#endif
+ }
+ 
+ GLES2DecoderImpl::GLES2DecoderImpl(
+diff --git a/gpu/ipc/service/gpu_init.cc b/gpu/ipc/service/gpu_init.cc
+index 40977d9b..50171e20 100644
+--- a/gpu/ipc/service/gpu_init.cc
++++ b/gpu/ipc/service/gpu_init.cc
+@@ -510,8 +510,9 @@
+ 
+   auto impl = gl::GetGLImplementationParts();
+   bool gl_disabled = impl == gl::kGLImplementationDisabled;
+-  bool is_swangle = impl == gl::ANGLEImplementation::kSwiftShader;
+ 
++#if BUILDFLAG(ENABLE_VALIDATING_COMMAND_DECODER)
++  bool is_swangle = impl == gl::ANGLEImplementation::kSwiftShader;
+   // Compute passthrough decoder status before ComputeGpuFeatureInfo below.
+   // Do this after GL is initialized so extensions can be queried.
+   // Using SwANGLE forces the passthrough command decoder.
+@@ -533,6 +534,20 @@
+   }
+   gpu_preferences_.use_passthrough_cmd_decoder =
+       gpu_info_.passthrough_cmd_decoder;
++#else
++  // If gl is disabled passthrough/validating command decoder doesn't matter. If
++  // it's not ensure that passthrough command decoder is supported as it's our
++  // only option.
++  if (!gl_disabled) {
++    LOG_IF(FATAL, !gles2::PassthroughCommandDecoderSupported())
++        << "Passthrough is not supported, GL is "
++        << gl::GetGLImplementationGLName(gl::GetGLImplementationParts())
++        << ", ANGLE is "
++        << gl::GetGLImplementationANGLEName(gl::GetGLImplementationParts());
++    gpu_info_.passthrough_cmd_decoder = true;
++    gpu_preferences_.use_passthrough_cmd_decoder = true;
++  }
++#endif
+ 
+   // We need to collect GL strings (VENDOR, RENDERER) for blocklisting purposes.
+   if (!gl_disabled) {

chromium-112-enable-vaapi-ozone-wayland.patch

@@ -0,0 +1,21 @@
+author	Yaowei Zhou <yaowei.zhou@intel.com>	Thu Feb 02 06:18:34 2023
+committer	Yaowei Zhou <yaowei.zhou@intel.com>	Thu Feb 02 06:18:34 2023
+tree	62a79c7f155fc32140d3aa4c4a6b01b8d7eddfcc
+parent	98e427b87ff8447180a60f20ee3792dcbd649481 [diff]
+Enable VA-API flag on ozone wayland
+
+Bug: POC
+Change-Id: I09f696bfe3be82930161ce005152d1397b93f636
+diff --git a/ui/ozone/platform/wayland/ozone_platform_wayland.cc b/ui/ozone/platform/wayland/ozone_platform_wayland.cc
+index b3190c6b..4a2c3bb 100644
+--- a/ui/ozone/platform/wayland/ozone_platform_wayland.cc
++++ b/ui/ozone/platform/wayland/ozone_platform_wayland.cc
+@@ -309,6 +309,8 @@
+       properties->supports_global_screen_coordinates =
+           features::IsWaylandScreenCoordinatesEnabled();
+ 
++      properties->supports_vaapi_x11 = true;
++
+       initialised = true;
+     }
+ 

chromium-112-invert_of_GLImageNativePixmap_NativePixmapEGLBinding.patch

@@ -0,0 +1,630 @@
+commit 7f0858c08dcef70ca26ce8527bbedfcc5c5218d3
+Author: Colin Blundell <blundell@chromium.org>
+Date:   Thu Feb 23 14:19:33 2023 +0000
+
+    [Ozone] Invert layering of GLImageNativePixmap & NativePixmapEGLBinding
+    
+    NativePixmapEGLBinding is currently a thin layer on top of
+    GLImageNativePixmap. This CL inverts the layering so that
+    GLImageNativePixmap instead sits on top of NativePixmapEGLBinding
+    (via the public Ozone ImportNativePixmap() method, for which all
+    implementations return NativePixmapEGLBinding). Note that this entails
+    moving GLImageNativePixmap into //gpu, as //ui/gl cannot depend on
+    //ozone/public.
+    
+    This inversion means that
+    (a) the SharedImage Ozone backing/representations no longer use GLImage
+    (b) when we no longer need GLImageNativePixmap we can simply directly
+    eliminate it.
+    
+    Followup CLs will fold NativePixmapEGLBindingHelper into
+    NativePixmapEGLBinding and make GLImageNativePixmap creation private
+    with friending to ensure that no more usage of the deprecated class
+    creeps in.
+    
+    Bug: 1412692
+    Change-Id: I5f01e9b1f616dd99b61cd203662d0d02d3da7b3e
+    Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4262390
+    Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
+    Reviewed-by: ccameron chromium <ccameron@chromium.org>
+    Reviewed-by: Andres Calderon Jaramillo <andrescj@chromium.org>
+    Commit-Queue: Colin Blundell <blundell@chromium.org>
+    Cr-Commit-Position: refs/heads/main@{#1108909}
+
+diff --git a/gpu/command_buffer/service/BUILD.gn b/gpu/command_buffer/service/BUILD.gn
+index d08be597e3e5d..5ad724dd57bbb 100644
+--- a/gpu/command_buffer/service/BUILD.gn
++++ b/gpu/command_buffer/service/BUILD.gn
+@@ -397,6 +397,8 @@ target(link_target_type, "gles2_sources") {
+ 
+   if (use_ozone) {
+     sources += [
++      "shared_image/gl_image_native_pixmap.cc",
++      "shared_image/gl_image_native_pixmap.h",
+       "shared_image/gl_ozone_image_representation.cc",
+       "shared_image/gl_ozone_image_representation.h",
+       "shared_image/ozone_image_backing.cc",
+diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
+index e3f5b3c5721cf..a297347c19670 100644
+--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
++++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
+@@ -120,10 +120,10 @@
+ #endif
+ 
+ #if BUILDFLAG(IS_OZONE)
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "ui/gfx/buffer_format_util.h"
+ #include "ui/gfx/buffer_usage_util.h"
+ #include "ui/gfx/native_pixmap.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/ozone/public/ozone_platform.h"
+ #include "ui/ozone/public/surface_factory_ozone.h"
+ #endif
+@@ -499,7 +499,7 @@ class BackTexture {
+ #if BUILDFLAG(IS_OZONE)
+   // The image that backs the texture, if its backed by a native
+   // GpuMemoryBuffer.
+-  scoped_refptr<gl::GLImageNativePixmap> image_;
++  scoped_refptr<GLImageNativePixmap> image_;
+ #endif
+ };
+ 
+@@ -2522,7 +2522,7 @@ class GLES2DecoderImpl : public GLES2Decoder,
+   // Note: Creation of anonymous images is possible only on Ozone.
+ #if BUILDFLAG(IS_OZONE)
+   bool SupportsCreateAnonymousImage();
+-  scoped_refptr<gl::GLImageNativePixmap> CreateAnonymousImage(
++  scoped_refptr<GLImageNativePixmap> CreateAnonymousImage(
+       const gfx::Size& size,
+       gfx::BufferFormat format,
+       bool* is_cleared,
+@@ -3242,7 +3242,7 @@ bool BackTexture::AllocateNativeGpuMemoryBuffer(const gfx::Size& size,
+     // duplicate BGRX_8888.
+     buffer_format = gfx::BufferFormat::BGRX_8888;
+   }
+-  scoped_refptr<gl::GLImageNativePixmap> image = decoder_->CreateAnonymousImage(
++  scoped_refptr<GLImageNativePixmap> image = decoder_->CreateAnonymousImage(
+       size, buffer_format, &is_cleared, Target(), id());
+   if (!image)
+     return false;
+@@ -19592,7 +19592,7 @@ bool GLES2DecoderImpl::SupportsCreateAnonymousImage() {
+       .supports_native_pixmaps;
+ }
+ 
+-scoped_refptr<gl::GLImageNativePixmap> GLES2DecoderImpl::CreateAnonymousImage(
++scoped_refptr<GLImageNativePixmap> GLES2DecoderImpl::CreateAnonymousImage(
+     const gfx::Size& size,
+     gfx::BufferFormat format,
+     bool* is_cleared,
+@@ -19612,8 +19612,8 @@ scoped_refptr<gl::GLImageNativePixmap> GLES2DecoderImpl::CreateAnonymousImage(
+                << gfx::BufferUsageToString(usage);
+     return nullptr;
+   }
+-  auto image = gl::GLImageNativePixmap::Create(size, format, std::move(pixmap),
+-                                               target, texture_id);
++  auto image = GLImageNativePixmap::Create(size, format, std::move(pixmap),
++                                           target, texture_id);
+   if (!image) {
+     LOG(ERROR) << "Failed to create GLImage " << size.ToString() << ", "
+                << gfx::BufferFormatToString(format) << ", usage "
+diff --git a/ui/gl/gl_image_native_pixmap.cc b/gpu/command_buffer/service/shared_image/gl_image_native_pixmap.cc
+similarity index 73%
+rename from ui/gl/gl_image_native_pixmap.cc
+rename to gpu/command_buffer/service/shared_image/gl_image_native_pixmap.cc
+index 6cbe7be2899de..d9101fbda893b 100644
+--- a/ui/gl/gl_image_native_pixmap.cc
++++ b/gpu/command_buffer/service/shared_image/gl_image_native_pixmap.cc
+@@ -2,9 +2,13 @@
+ // Use of this source code is governed by a BSD-style license that can be
+ // found in the LICENSE file.
+ 
+-#include "ui/gl/gl_image_native_pixmap.h"
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ 
+-namespace gl {
++#include "ui/ozone/public/native_pixmap_gl_binding.h"
++#include "ui/ozone/public/ozone_platform.h"
++#include "ui/ozone/public/surface_factory_ozone.h"
++
++namespace gpu {
+ 
+ scoped_refptr<GLImageNativePixmap> GLImageNativePixmap::Create(
+     const gfx::Size& size,
+@@ -47,18 +51,18 @@ bool GLImageNativePixmap::InitializeFromNativePixmap(
+     const gfx::ColorSpace& color_space,
+     GLenum target,
+     GLuint texture_id) {
+-  binding_helper_ = NativePixmapEGLBindingHelper::CreateForPlane(
+-      size_, format, plane, std::move(pixmap), color_space, target, texture_id);
++  pixmap_gl_binding_ =
++      ui::OzonePlatform::GetInstance()
++          ->GetSurfaceFactoryOzone()
++          ->GetCurrentGLOzone()
++          ->ImportNativePixmap(std::move(pixmap), format, plane, size_,
++                               color_space, target, texture_id);
+ 
+-  return !!binding_helper_;
++  return !!pixmap_gl_binding_;
+ }
+ 
+ gfx::Size GLImageNativePixmap::GetSize() {
+   return size_;
+ }
+ 
+-unsigned GLImageNativePixmap::GetInternalFormat() {
+-  return binding_helper_->GetInternalFormat();
+-}
+-
+-}  // namespace gl
++}  // namespace gpu
+diff --git a/ui/gl/gl_image_native_pixmap.h b/gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h
+similarity index 72%
+rename from ui/gl/gl_image_native_pixmap.h
+rename to gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h
+index 5ff5e91b3ec18..4087360b04b45 100644
+--- a/ui/gl/gl_image_native_pixmap.h
++++ b/gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h
+@@ -2,21 +2,24 @@
+ // Use of this source code is governed by a BSD-style license that can be
+ // found in the LICENSE file.
+ 
+-#ifndef UI_GL_GL_IMAGE_NATIVE_PIXMAP_H_
+-#define UI_GL_GL_IMAGE_NATIVE_PIXMAP_H_
++#ifndef GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_GL_IMAGE_NATIVE_PIXMAP_H_
++#define GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_GL_IMAGE_NATIVE_PIXMAP_H_
+ 
+ #include <stdint.h>
+ 
++#include "gpu/gpu_gles2_export.h"
+ #include "ui/gfx/color_space.h"
+ #include "ui/gfx/native_pixmap.h"
+ #include "ui/gl/gl_bindings.h"
+-#include "ui/gl/gl_export.h"
+ #include "ui/gl/gl_image.h"
+-#include "ui/gl/native_pixmap_egl_binding_helper.h"
+ 
+-namespace gl {
++namespace ui {
++class NativePixmapGLBinding;
++}
+ 
+-class GL_EXPORT GLImageNativePixmap : public GLImage {
++namespace gpu {
++
++class GPU_GLES2_EXPORT GLImageNativePixmap : public gl::GLImage {
+  public:
+   // Create an EGLImage from a given NativePixmap and bind |texture_id| to
+   // |target| following by binding the image to |target|.
+@@ -41,22 +44,15 @@ class GL_EXPORT GLImageNativePixmap : public GLImage {
+       GLenum target,
+       GLuint texture_id);
+ 
+-  // Get the GL internal format of the image.
+-  // It is aligned with glTexImage{2|3}D's parameter |internalformat|.
+-  unsigned GetInternalFormat();
+-
+   // Overridden from GLImage:
+   gfx::Size GetSize() override;
+ 
+- protected:
+-  ~GLImageNativePixmap() override;
+-
+  private:
+   explicit GLImageNativePixmap(const gfx::Size& size);
++  ~GLImageNativePixmap() override;
+ 
+-  // Create an EGLImage from a given NativePixmap and bind |texture_id| to
+-  // |target| followed by binding the image to |target|. This EGLImage can be
+-  // converted to a GL texture.
++  // Create a NativePixmapGLBinding from a given NativePixmap. Returns true iff
++  // the binding was successfully created.
+   bool InitializeFromNativePixmap(gfx::BufferFormat format,
+                                   gfx::BufferPlane plane,
+                                   scoped_refptr<gfx::NativePixmap> pixmap,
+@@ -64,10 +60,10 @@ class GL_EXPORT GLImageNativePixmap : public GLImage {
+                                   GLenum target,
+                                   GLuint texture_id);
+ 
+-  std::unique_ptr<NativePixmapEGLBindingHelper> binding_helper_;
++  std::unique_ptr<ui::NativePixmapGLBinding> pixmap_gl_binding_;
+   const gfx::Size size_;
+ };
+ 
+-}  // namespace gl
++}  // namespace gpu
+ 
+-#endif  // UI_GL_GL_IMAGE_NATIVE_PIXMAP_H_
++#endif  // GPU_COMMAND_BUFFER_SERVICE_SHARED_IMAGE_GL_IMAGE_NATIVE_PIXMAP_H_
+diff --git a/gpu/command_buffer/service/shared_image/gl_ozone_image_representation.h b/gpu/command_buffer/service/shared_image/gl_ozone_image_representation.h
+index 31723894088e1..ade337bde9966 100644
+--- a/gpu/command_buffer/service/shared_image/gl_ozone_image_representation.h
++++ b/gpu/command_buffer/service/shared_image/gl_ozone_image_representation.h
+@@ -14,7 +14,6 @@
+ #include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
+ #include "gpu/command_buffer/service/texture_manager.h"
+ #include "ui/gfx/native_pixmap.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/ozone/public/native_pixmap_gl_binding.h"
+ 
+ namespace gpu {
+diff --git a/gpu/command_buffer/service/shared_image/ozone_image_backing.cc b/gpu/command_buffer/service/shared_image/ozone_image_backing.cc
+index 8d4a7d9306eb1..7a652ae425c0e 100644
+--- a/gpu/command_buffer/service/shared_image/ozone_image_backing.cc
++++ b/gpu/command_buffer/service/shared_image/ozone_image_backing.cc
+@@ -36,7 +36,6 @@
+ #include "ui/gfx/native_pixmap.h"
+ #include "ui/gfx/native_widget_types.h"
+ #include "ui/gl/buildflags.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ 
+ #if BUILDFLAG(ENABLE_VULKAN)
+ #include "gpu/command_buffer/service/shared_image/skia_vk_ozone_image_representation.h"
+diff --git a/media/gpu/v4l2/BUILD.gn b/media/gpu/v4l2/BUILD.gn
+index 12e6b66cf7b89..ff7b5a1a50a38 100644
+--- a/media/gpu/v4l2/BUILD.gn
++++ b/media/gpu/v4l2/BUILD.gn
+@@ -98,6 +98,7 @@ source_set("v4l2") {
+     ":libv4l2_stubs",
+     ":v4l2_status",
+     "//base",
++    "//gpu/command_buffer/service:gles2",
+     "//gpu/ipc/common",
+     "//gpu/ipc/service",
+     "//media",
+diff --git a/media/gpu/v4l2/generic_v4l2_device.cc b/media/gpu/v4l2/generic_v4l2_device.cc
+index bdbb256ed578c..337ec0e7b372b 100644
+--- a/media/gpu/v4l2/generic_v4l2_device.cc
++++ b/media/gpu/v4l2/generic_v4l2_device.cc
+@@ -23,6 +23,7 @@
+ #include "base/strings/stringprintf.h"
+ #include "base/trace_event/trace_event.h"
+ #include "build/build_config.h"
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "media/base/video_types.h"
+ #include "media/gpu/buildflags.h"
+ #include "media/gpu/chromeos/fourcc.h"
+@@ -32,7 +33,6 @@
+ #include "ui/gfx/native_pixmap_handle.h"
+ #include "ui/gl/egl_util.h"
+ #include "ui/gl/gl_bindings.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/ozone/public/ozone_platform.h"
+ #include "ui/ozone/public/surface_factory_ozone.h"
+ 
+@@ -281,7 +281,7 @@ EGLImageKHR GenericV4L2Device::CreateEGLImage(
+   return egl_image;
+ }
+ 
+-scoped_refptr<gl::GLImageNativePixmap> GenericV4L2Device::CreateGLImage(
++scoped_refptr<gpu::GLImageNativePixmap> GenericV4L2Device::CreateGLImage(
+     const gfx::Size& size,
+     const Fourcc fourcc,
+     gfx::NativePixmapHandle handle,
+@@ -317,7 +317,7 @@ scoped_refptr<gl::GLImageNativePixmap> GenericV4L2Device::CreateGLImage(
+   DCHECK(pixmap);
+ 
+   // TODO(b/220336463): plumb the right color space.
+-  auto image = gl::GLImageNativePixmap::Create(
++  auto image = gpu::GLImageNativePixmap::Create(
+       size, buffer_format, std::move(pixmap), target, texture_id);
+   DCHECK(image);
+   return image;
+diff --git a/media/gpu/v4l2/generic_v4l2_device.h b/media/gpu/v4l2/generic_v4l2_device.h
+index bb9ce391c15bd..fd84aee27097e 100644
+--- a/media/gpu/v4l2/generic_v4l2_device.h
++++ b/media/gpu/v4l2/generic_v4l2_device.h
+@@ -55,7 +55,7 @@ class GenericV4L2Device : public V4L2Device {
+                              const Fourcc fourcc,
+                              gfx::NativePixmapHandle handle) const override;
+ 
+-  scoped_refptr<gl::GLImageNativePixmap> CreateGLImage(
++  scoped_refptr<gpu::GLImageNativePixmap> CreateGLImage(
+       const gfx::Size& size,
+       const Fourcc fourcc,
+       gfx::NativePixmapHandle handle,
+diff --git a/media/gpu/v4l2/v4l2_device.h b/media/gpu/v4l2/v4l2_device.h
+index bdc39bf65ae38..ee74cbcd39957 100644
+--- a/media/gpu/v4l2/v4l2_device.h
++++ b/media/gpu/v4l2/v4l2_device.h
+@@ -28,6 +28,7 @@
+ #include "base/files/scoped_file.h"
+ #include "base/memory/ref_counted.h"
+ #include "base/sequence_checker.h"
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "media/base/video_codecs.h"
+ #include "media/base/video_decoder_config.h"
+ #include "media/base/video_frame.h"
+@@ -42,7 +43,6 @@
+ #include "ui/gfx/geometry/size.h"
+ #include "ui/gfx/native_pixmap_handle.h"
+ #include "ui/gl/gl_bindings.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ 
+ // TODO(mojahsu): remove this once V4L2 headers are updated.
+ #ifndef V4L2_PIX_FMT_JPEG_RAW
+@@ -777,7 +777,7 @@ class MEDIA_GPU_EXPORT V4L2Device
+ 
+   // Create a GLImageNativePixmap from provided |handle|, taking full ownership
+   // of it.
+-  virtual scoped_refptr<gl::GLImageNativePixmap> CreateGLImage(
++  virtual scoped_refptr<gpu::GLImageNativePixmap> CreateGLImage(
+       const gfx::Size& size,
+       const Fourcc fourcc,
+       gfx::NativePixmapHandle handle,
+diff --git a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
+index a51acedc105b7..78cc605e986e6 100644
+--- a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
++++ b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
+@@ -30,6 +30,7 @@
+ #include "base/time/time.h"
+ #include "base/trace_event/memory_dump_manager.h"
+ #include "base/trace_event/trace_event.h"
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "media/base/bind_to_current_loop.h"
+ #include "media/base/media_switches.h"
+ #include "media/base/scopedfd_helper.h"
+@@ -49,7 +50,6 @@
+ #include "ui/gl/gl_bindings.h"
+ #include "ui/gl/gl_context.h"
+ #include "ui/gl/gl_display.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/gl/gl_surface_egl.h"
+ #include "ui/gl/scoped_binders.h"
+ 
+@@ -1444,7 +1444,7 @@ void V4L2SliceVideoDecodeAccelerator::CreateGLImageFor(
+     return;
+   }
+ 
+-  scoped_refptr<gl::GLImageNativePixmap> gl_image =
++  scoped_refptr<gpu::GLImageNativePixmap> gl_image =
+       gl_device->CreateGLImage(visible_size, fourcc, std::move(handle),
+                                gl_device->GetTextureTarget(), texture_id);
+   if (!gl_image) {
+diff --git a/media/gpu/vaapi/BUILD.gn b/media/gpu/vaapi/BUILD.gn
+index 1ecf8854d02e7..7687384553806 100644
+--- a/media/gpu/vaapi/BUILD.gn
++++ b/media/gpu/vaapi/BUILD.gn
+@@ -96,6 +96,7 @@ source_set("vaapi") {
+     ":vaapi_status",
+     "//base",
+     "//build:chromeos_buildflags",
++    "//gpu/command_buffer/service:gles2",
+     "//gpu/config",
+     "//gpu/ipc/common",
+     "//gpu/ipc/service",
+diff --git a/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc b/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
+index 06617ffec8e5a..626dda6312213 100644
+--- a/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
++++ b/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
+@@ -4,6 +4,7 @@
+ 
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h"
+ 
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "media/base/format_utils.h"
+ #include "media/gpu/buffer_validation.h"
+ #include "media/gpu/chromeos/platform_video_frame_utils.h"
+@@ -15,7 +16,6 @@
+ #include "ui/gfx/linux/native_pixmap_dmabuf.h"
+ #include "ui/gfx/native_pixmap.h"
+ #include "ui/gl/gl_bindings.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/gl/scoped_binders.h"
+ #include "ui/ozone/public/ozone_platform.h"
+ #include "ui/ozone/public/surface_factory_ozone.h"
+@@ -87,7 +87,7 @@ VaapiStatus VaapiPictureNativePixmapOzone::Initialize(
+   const gfx::BufferFormat format = pixmap->GetBufferFormat();
+ 
+   // TODO(b/220336463): plumb the right color space.
+-  auto image = gl::GLImageNativePixmap::Create(
++  auto image = gpu::GLImageNativePixmap::Create(
+       visible_size_, format, std::move(pixmap),
+       base::strict_cast<GLenum>(texture_target_),
+       base::strict_cast<GLuint>(texture_id_));
+diff --git a/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h b/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h
+index 101728f36c1e1..eaced9a8ccadf 100644
+--- a/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h
++++ b/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h
+@@ -17,7 +17,7 @@ namespace gfx {
+ class NativePixmap;
+ }  // namespace gfx
+ 
+-namespace gl {
++namespace gpu {
+ class GLImageNativePixmap;
+ }
+ 
+@@ -55,7 +55,7 @@ class VaapiPictureNativePixmapOzone : public VaapiPictureNativePixmap {
+   VaapiStatus Initialize(scoped_refptr<gfx::NativePixmap> pixmap);
+ 
+   // GLImage bound to the GL textures used by the VDA client.
+-  scoped_refptr<gl::GLImageNativePixmap> gl_image_;
++  scoped_refptr<gpu::GLImageNativePixmap> gl_image_;
+ };
+ 
+ }  // namespace media
+diff --git a/ui/gfx/linux/native_pixmap_dmabuf.h b/ui/gfx/linux/native_pixmap_dmabuf.h
+index 7f134110417ea..f12d4f5eac89d 100644
+--- a/ui/gfx/linux/native_pixmap_dmabuf.h
++++ b/ui/gfx/linux/native_pixmap_dmabuf.h
+@@ -17,7 +17,7 @@
+ namespace gfx {
+ 
+ // This class converts a gfx::NativePixmapHandle to a gfx::NativePixmap.
+-// It is useful because gl::GLImageNativePixmap::Initialize only takes
++// It is useful because gpu::GLImageNativePixmap::Initialize only takes
+ // a gfx::NativePixmap as input.
+ class GFX_EXPORT NativePixmapDmaBuf : public gfx::NativePixmap {
+  public:
+diff --git a/ui/gl/BUILD.gn b/ui/gl/BUILD.gn
+index cc23c0a8b4c64..2a07859c4dad8 100644
+--- a/ui/gl/BUILD.gn
++++ b/ui/gl/BUILD.gn
+@@ -226,8 +226,6 @@ component("gl") {
+ 
+     if (is_linux || is_chromeos || use_ozone) {
+       sources += [
+-        "gl_image_native_pixmap.cc",
+-        "gl_image_native_pixmap.h",
+         "native_pixmap_egl_binding_helper.cc",
+         "native_pixmap_egl_binding_helper.h",
+       ]
+diff --git a/ui/ozone/common/native_pixmap_egl_binding.cc b/ui/ozone/common/native_pixmap_egl_binding.cc
+index 8dce01a41281e..2e18e73eb6cbb 100644
+--- a/ui/ozone/common/native_pixmap_egl_binding.cc
++++ b/ui/ozone/common/native_pixmap_egl_binding.cc
+@@ -8,7 +8,7 @@
+ #include "base/memory/scoped_refptr.h"
+ #include "base/notreached.h"
+ #include "ui/gl/gl_bindings.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
++#include "ui/gl/native_pixmap_egl_binding_helper.h"
+ 
+ namespace ui {
+ 
+@@ -50,9 +50,9 @@ unsigned BufferFormatToGLDataType(gfx::BufferFormat format) {
+ }  // namespace
+ 
+ NativePixmapEGLBinding::NativePixmapEGLBinding(
+-    scoped_refptr<gl::GLImageNativePixmap> gl_image,
++    std::unique_ptr<gl::NativePixmapEGLBindingHelper> binding_helper,
+     gfx::BufferFormat format)
+-    : gl_image_(std::move(gl_image)), format_(format) {}
++    : binding_helper_(std::move(binding_helper)), format_(format) {}
+ NativePixmapEGLBinding::~NativePixmapEGLBinding() = default;
+ 
+ // static
+@@ -64,22 +64,22 @@ std::unique_ptr<NativePixmapGLBinding> NativePixmapEGLBinding::Create(
+     const gfx::ColorSpace& color_space,
+     GLenum target,
+     GLuint texture_id) {
+-  auto gl_image = gl::GLImageNativePixmap::CreateForPlane(
++  auto binding_helper = gl::NativePixmapEGLBindingHelper::CreateForPlane(
+       plane_size, plane_format, plane, std::move(pixmap), color_space, target,
+       texture_id);
+-  if (!gl_image) {
+-    LOG(ERROR) << "Unable to initialize GL image from pixmap";
++  if (!binding_helper) {
++    LOG(ERROR) << "Unable to initialize binding from pixmap";
+     return nullptr;
+   }
+ 
+-  auto binding = std::make_unique<NativePixmapEGLBinding>(std::move(gl_image),
+-                                                          plane_format);
++  auto binding = std::make_unique<NativePixmapEGLBinding>(
++      std::move(binding_helper), plane_format);
+ 
+   return binding;
+ }
+ 
+ GLuint NativePixmapEGLBinding::GetInternalFormat() {
+-  return gl_image_->GetInternalFormat();
++  return binding_helper_->GetInternalFormat();
+ }
+ 
+ GLenum NativePixmapEGLBinding::GetDataType() {
+diff --git a/ui/ozone/common/native_pixmap_egl_binding.h b/ui/ozone/common/native_pixmap_egl_binding.h
+index 44d68be3527a4..c0382b1068426 100644
+--- a/ui/ozone/common/native_pixmap_egl_binding.h
++++ b/ui/ozone/common/native_pixmap_egl_binding.h
+@@ -15,16 +15,17 @@ class ColorSpace;
+ }
+ 
+ namespace gl {
+-class GLImageNativePixmap;
++class NativePixmapEGLBindingHelper;
+ }
+ 
+ namespace ui {
+ 
+-// A binding maintained between GLImageNativePixmap and GL Textures in Ozone.
++// A binding maintained between NativePixmap and GL Textures in Ozone.
+ class NativePixmapEGLBinding : public NativePixmapGLBinding {
+  public:
+-  NativePixmapEGLBinding(scoped_refptr<gl::GLImageNativePixmap> gl_image,
+-                         gfx::BufferFormat format);
++  NativePixmapEGLBinding(
++      std::unique_ptr<gl::NativePixmapEGLBindingHelper> binding_helper,
++      gfx::BufferFormat format);
+   ~NativePixmapEGLBinding() override;
+ 
+   static std::unique_ptr<NativePixmapGLBinding> Create(
+@@ -41,10 +42,7 @@ class NativePixmapEGLBinding : public NativePixmapGLBinding {
+   GLenum GetDataType() override;
+ 
+  private:
+-  // TODO(hitawala): Merge BindTexImage, Initialize from GLImage and its
+-  // subclass NativePixmap to NativePixmapEGLBinding once we stop using them
+-  // elsewhere eg. VDA decoders in media.
+-  scoped_refptr<gl::GLImageNativePixmap> gl_image_;
++  std::unique_ptr<gl::NativePixmapEGLBindingHelper> binding_helper_;
+ 
+   gfx::BufferFormat format_;
+ };
+diff --git a/ui/ozone/gl/BUILD.gn b/ui/ozone/gl/BUILD.gn
+index 4fc90f0471362..6064eb6f83a8c 100644
+--- a/ui/ozone/gl/BUILD.gn
++++ b/ui/ozone/gl/BUILD.gn
+@@ -9,6 +9,14 @@ test("ozone_gl_unittests") {
+ 
+   deps = [
+     "//base/test:test_support",
++
++    # NOTE: The above tests of gpu::GLImageNativePixmap cannot easily be made
++    # to run as part of //gpu's gl_tests or gpu_unittests: they crash when run
++    # with the former due to differences in GL configuration, and they are
++    # skipped when run with the latter due to differences in Ozone
++    # configuration. Simply leave them here with this dependency for the short
++    # time remaining until GLImageNativePixmap is eliminated altogether.
++    "//gpu/command_buffer/service:gles2",
+     "//testing/gtest",
+     "//ui/gfx",
+     "//ui/gl:run_all_unittests",
+diff --git a/ui/ozone/gl/DEPS b/ui/ozone/gl/DEPS
+new file mode 100644
+index 0000000000000..e6142e85d2154
+--- /dev/null
++++ b/ui/ozone/gl/DEPS
+@@ -0,0 +1,6 @@
++specific_include_rules = {
++  # NOTE: See comment in ./BUILD.gn with respect to this dependency.
++  "gl_image_ozone_native_pixmap_unittest\.cc": [
++    "+gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h",
++  ],
++}
+diff --git a/ui/ozone/gl/gl_image_ozone_native_pixmap_unittest.cc b/ui/ozone/gl/gl_image_ozone_native_pixmap_unittest.cc
+index 9a538903c8ff0..1527df91a3238 100644
+--- a/ui/ozone/gl/gl_image_ozone_native_pixmap_unittest.cc
++++ b/ui/ozone/gl/gl_image_ozone_native_pixmap_unittest.cc
+@@ -5,10 +5,10 @@
+ #include <stdint.h>
+ #include <memory>
+ 
++#include "gpu/command_buffer/service/shared_image/gl_image_native_pixmap.h"
+ #include "testing/gtest/include/gtest/gtest.h"
+ #include "ui/gfx/buffer_types.h"
+ #include "ui/gfx/client_native_pixmap.h"
+-#include "ui/gl/gl_image_native_pixmap.h"
+ #include "ui/gl/test/gl_image_test_template.h"
+ #include "ui/ozone/public/client_native_pixmap_factory_ozone.h"
+ #include "ui/ozone/public/ozone_platform.h"
+@@ -83,7 +83,7 @@ class GLImageNativePixmapTestDelegate : public GLImageTestDelegateBase {
+       glGenTextures(1, &texture_id_);
+     }
+ 
+-    auto image = gl::GLImageNativePixmap::Create(
++    auto image = gpu::GLImageNativePixmap::Create(
+         size, format, std::move(pixmap), GetTextureTarget(), texture_id_);
+     EXPECT_TRUE(image);
+     return image;
+@@ -100,8 +100,9 @@ class GLImageNativePixmapTestDelegate : public GLImageTestDelegateBase {
+         format == gfx::BufferFormat::YUV_420_BIPLANAR) {
+       return 1;
+     }
+-    if (format == gfx::BufferFormat::P010)
++    if (format == gfx::BufferFormat::P010) {
+       return 3;
++    }
+     return 0;
+   }
+ 

chromium-112-ozone-wayland-vaapi-support.patch

@@ -0,0 +1,625 @@
+diff -up chromium-112.0.5615.49/media/gpu/args.gni.wayland-vaapi chromium-112.0.5615.49/media/gpu/args.gni
+--- chromium-112.0.5615.49/media/gpu/args.gni.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/args.gni	2023-04-14 21:29:41.776328044 +0200
+@@ -6,10 +6,14 @@ import("//build/config/chromeos/ui_mode.
+ import("//build/config/ozone.gni")
+ 
+ declare_args() {
+-  # Indicates if X11 VA-API-based hardware acceleration is to be used.
+-  # See also the comment near the |use_vaapi| arg.
+-  use_vaapi_x11 = is_linux && ozone_platform_x11 &&
+-                  (target_cpu == "x86" || target_cpu == "x64") && !is_castos
++  # Build Chrome support for using VA-API over X11. Note that setting this to true is
++  # not a guarantee that Chrome will use (or even try to use) VA-API over X11. In
++  # particular, it is possible to build Chrome with support for VA-API over X11 but
++  # pick Wayland as the Ozone backend at runtime. In this case, Chrome will try to
++  # use VA-API over DRM.
++  support_vaapi_over_x11 =
++      is_linux && ozone_platform_x11 &&
++      (target_cpu == "x86" || target_cpu == "x64") && !is_castos
+ }
+ 
+ declare_args() {
+@@ -29,8 +33,9 @@ declare_args() {
+   # is typically the case on x86-based ChromeOS devices.
+   # VA-API should also be compiled by default on x11-using linux devices
+   # using x86/x64.
+-  use_vaapi = use_vaapi_x11 || (is_chromeos_lacros &&
+-                                (target_cpu == "x86" || target_cpu == "x64"))
++  use_vaapi =
++      support_vaapi_over_x11 ||
++      (is_chromeos_lacros && (target_cpu == "x86" || target_cpu == "x64"))
+ 
+   # Indicates if ChromeOS protected media support exists. This is used
+   # to enable the CDM daemon in Chrome OS as well as support for
+diff -up chromium-112.0.5615.49/media/gpu/BUILD.gn.wayland-vaapi chromium-112.0.5615.49/media/gpu/BUILD.gn
+--- chromium-112.0.5615.49/media/gpu/BUILD.gn.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/BUILD.gn	2023-04-14 21:29:41.776328044 +0200
+@@ -20,7 +20,7 @@ buildflag_header("buildflags") {
+     "USE_VAAPI_IMAGE_CODECS=$use_vaapi_image_codecs",
+     "USE_V4L2_CODEC=$use_v4l2_codec",
+     "USE_LIBV4L2=$use_v4lplugin",
+-    "USE_VAAPI_X11=$use_vaapi_x11",
++    "SUPPORT_VAAPI_OVER_X11=$support_vaapi_over_x11",
+   ]
+ }
+ 
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn
+--- chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/BUILD.gn	2023-04-14 21:29:41.776328044 +0200
+@@ -17,7 +17,7 @@ assert(use_vaapi)
+ generate_stubs("libva_stubs") {
+   extra_header = "va_stub_header.fragment"
+   sigs = [ "va.sigs" ]
+-  if (use_vaapi_x11) {
++  if (support_vaapi_over_x11) {
+     sigs += [ "va_x11.sigs" ]
+   }
+   if (is_chromeos_ash) {
+@@ -139,7 +139,7 @@ source_set("vaapi") {
+     ]
+   }
+ 
+-  if (use_vaapi_x11) {
++  if (support_vaapi_over_x11) {
+     deps += [ "//ui/gfx/x" ]
+     sources += [
+       "vaapi_picture_native_pixmap_angle.cc",
+@@ -213,7 +213,7 @@ source_set("common") {
+     deps += [ "//ui/ozone" ]
+   }
+ 
+-  if (use_vaapi_x11) {
++  if (support_vaapi_over_x11) {
+     deps += [ "//ui/gfx/x" ]
+   }
+ 
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.cc	2023-04-15 07:14:05.573796794 +0200
+@@ -13,9 +13,9 @@
+ #if BUILDFLAG(IS_OZONE)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h"
+ #endif  // BUILDFLAG(IS_OZONE)
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_angle.h"
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #if defined(USE_EGL)
+ #include "media/gpu/vaapi/vaapi_picture_native_pixmap_egl.h"
+ #endif
+@@ -41,19 +41,28 @@ std::unique_ptr<VaapiPicture> CreateVaap
+ 
+ }  // namespace
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++VaapiPictureFactory::VaapiPictureFactory(
++    absl::optional<bool> may_use_vaapi_over_x11)
++    : may_use_vaapi_over_x11_(may_use_vaapi_over_x11) {
++#else
+ VaapiPictureFactory::VaapiPictureFactory() {
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+   vaapi_impl_pairs_.insert(
+       std::make_pair(gl::kGLImplementationEGLGLES2,
+                      VaapiPictureFactory::kVaapiImplementationDrm));
+-#if BUILDFLAG(USE_VAAPI_X11)
+-  vaapi_impl_pairs_.insert(
+-      std::make_pair(gl::kGLImplementationEGLANGLE,
+-                     VaapiPictureFactory::kVaapiImplementationAngle));
+-#elif BUILDFLAG(IS_OZONE)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  CHECK(may_use_vaapi_over_x11_.has_value());
++  if (may_use_vaapi_over_x11_.value()) {
++    vaapi_impl_pairs_.insert(
++        std::make_pair(gl::kGLImplementationEGLANGLE,
++                       VaapiPictureFactory::kVaapiImplementationAngle));
++  }
++#else
+   vaapi_impl_pairs_.insert(
+       std::make_pair(gl::kGLImplementationEGLANGLE,
+                      VaapiPictureFactory::kVaapiImplementationDrm));
+-#endif
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+   DeterminePictureCreationAndDownloadingMechanism();
+ }
+@@ -93,19 +102,19 @@ VaapiPictureFactory::GetVaapiImplementat
+ }
+ 
+ uint32_t VaapiPictureFactory::GetGLTextureTarget() {
+-#if BUILDFLAG(USE_VAAPI_X11)
+-  return GL_TEXTURE_2D;
+-#else
++#if BUILDFLAG(IS_CHROMEOS)
+   return GL_TEXTURE_EXTERNAL_OES;
+-#endif
++#else
++  return GL_TEXTURE_2D;
++#endif  // BUILDFLAG(IS_CHROMEOS)
+ }
+ 
+ gfx::BufferFormat VaapiPictureFactory::GetBufferFormat() {
+-#if BUILDFLAG(USE_VAAPI_X11)
+-  return gfx::BufferFormat::RGBX_8888;
+-#else
++#if BUILDFLAG(IS_CHROMEOS)
+   return gfx::BufferFormat::YUV_420_BIPLANAR;
+-#endif
++#else
++  return gfx::BufferFormat::RGBX_8888;
++#endif  // BUILDFLAG(IS_CHROMEOS)
+ }
+ 
+ void VaapiPictureFactory::DeterminePictureCreationAndDownloadingMechanism() {
+@@ -113,19 +122,23 @@ void VaapiPictureFactory::DeterminePictu
+ #if BUILDFLAG(IS_OZONE)
+     // We can be called without GL initialized, which is valid if we use Ozone.
+     case kVaapiImplementationNone:
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++      DCHECK(may_use_vaapi_over_x11_.value_or(false));
++#endif
+       create_picture_cb_ = base::BindRepeating(
+           &CreateVaapiPictureNativeImpl<VaapiPictureNativePixmapOzone>);
+       needs_vpp_for_downloading_ = true;
+       break;
+ #endif  // BUILDFLAG(IS_OZONE)
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+     case kVaapiImplementationAngle:
++      DCHECK(may_use_vaapi_over_x11_.value_or(false));
+       create_picture_cb_ = base::BindRepeating(
+           &CreateVaapiPictureNativeImpl<VaapiPictureNativePixmapAngle>);
+       // Neither VaapiTFPPicture or VaapiPictureNativePixmapAngle needs the VPP.
+       needs_vpp_for_downloading_ = false;
+       break;
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+     case kVaapiImplementationDrm:
+ #if BUILDFLAG(IS_OZONE)
+       create_picture_cb_ = base::BindRepeating(
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_factory.h	2023-04-14 21:29:41.777328062 +0200
+@@ -35,7 +35,11 @@ class MEDIA_GPU_EXPORT VaapiPictureFacto
+     kVaapiImplementationAngle,
+   };
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  explicit VaapiPictureFactory(absl::optional<bool> may_use_vaapi_over_x11);
++#else
+   VaapiPictureFactory();
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+   VaapiPictureFactory(const VaapiPictureFactory&) = delete;
+   VaapiPictureFactory& operator=(const VaapiPictureFactory&) = delete;
+@@ -84,6 +88,11 @@ class MEDIA_GPU_EXPORT VaapiPictureFacto
+ 
+   CreatePictureCB create_picture_cb_;
+   bool needs_vpp_for_downloading_ = false;
++
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  // See comment in `VaapiWrapper::MayUseVaapiOverX11()`.
++  absl::optional<bool> may_use_vaapi_over_x11_;
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ };
+ 
+ }  // namespace media
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc	2023-04-14 21:29:41.777328062 +0200
+@@ -113,7 +113,7 @@ VaapiStatus VaapiPictureNativePixmapOzon
+   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
+   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
+   gfx::BufferUsage buffer_usage = gfx::BufferUsage::SCANOUT_VDA_WRITE;
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+   // The 'VaapiVideoDecodeAccelerator' requires the VPP to download the decoded
+   // frame from the internal surface to the allocated native pixmap.
+   // 'SCANOUT_VDA_WRITE' is used for 'YUV_420_BIPLANAR' on ChromeOS; For Linux,
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc.wayland-vaapi	2023-04-14 21:29:41.775328024 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator.cc	2023-04-14 21:29:41.777328062 +0200
+@@ -185,7 +185,12 @@ bool VaapiVideoDecodeAccelerator::Initia
+                                              Client* client) {
+   DCHECK(task_runner_->BelongsToCurrentThread());
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  vaapi_picture_factory_ =
++      std::make_unique<VaapiPictureFactory>(VaapiWrapper::MayUseVaapiOverX11());
++#else
+   vaapi_picture_factory_ = std::make_unique<VaapiPictureFactory>();
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+   if (config.is_encrypted()) {
+     NOTREACHED() << "Encrypted streams are not supported for this VDA";
+@@ -1211,7 +1216,7 @@ VaapiVideoDecodeAccelerator::GetSupporte
+ 
+ VaapiVideoDecodeAccelerator::BufferAllocationMode
+ VaapiVideoDecodeAccelerator::DecideBufferAllocationMode() {
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+   // The IMPORT mode is used for Android on Chrome OS, so this doesn't apply
+   // here.
+   DCHECK_NE(output_mode_, VideoDecodeAccelerator::Config::OutputMode::IMPORT);
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc	2023-04-15 07:38:19.058957112 +0200
+@@ -41,6 +41,11 @@ struct TestParams {
+   bool decode_using_client_picture_buffers;
+ };
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++// TODO: Add it in TestParams to cover Ozone/Wayland.
++bool kMayUseVaapiOverX11 = true;
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
+ constexpr int32_t kBitstreamId = 123;
+ constexpr size_t kInputSize = 256;
+ 
+@@ -134,7 +139,13 @@ class MockVaapiPicture : public VaapiPic
+ 
+ class MockVaapiPictureFactory : public VaapiPictureFactory {
+  public:
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  explicit MockVaapiPictureFactory(absl::optional<bool> may_use_vaapi_over_x11)
++      : VaapiPictureFactory(may_use_vaapi_over_x11) {}
++#else
+   MockVaapiPictureFactory() = default;
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
+   ~MockVaapiPictureFactory() override = default;
+ 
+   MOCK_METHOD3(MockCreateVaapiPicture,
+@@ -167,7 +178,12 @@ class VaapiVideoDecodeAcceleratorTest :
+                     const scoped_refptr<gl::GLImage>& image) { return true; })),
+         decoder_thread_("VaapiVideoDecodeAcceleratorTestThread"),
+         mock_decoder_(new ::testing::StrictMock<MockAcceleratedVideoDecoder>),
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++        mock_vaapi_picture_factory_(
++            new MockVaapiPictureFactory(kMayUseVaapiOverX11)),
++#else
+         mock_vaapi_picture_factory_(new MockVaapiPictureFactory()),
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+         mock_vaapi_wrapper_(new MockVaapiWrapper(VaapiWrapper::kDecode)),
+         mock_vpp_vaapi_wrapper_(new MockVaapiWrapper(VaapiWrapper::kDecode)),
+         weak_ptr_factory_(this) {
+@@ -422,11 +438,13 @@ TEST_P(VaapiVideoDecodeAcceleratorTest,
+             mock_vaapi_picture_factory_->GetVaapiImplementation(
+                 gl::kGLImplementationEGLGLES2));
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
+-  EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationAngle,
+-            mock_vaapi_picture_factory_->GetVaapiImplementation(
+-                gl::kGLImplementationEGLANGLE));
+-#elif BUILDFLAG(IS_OZONE)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  if (kMayUseVaapiOverX11) {
++    EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationAngle,
++              mock_vaapi_picture_factory_->GetVaapiImplementation(
++                  gl::kGLImplementationEGLANGLE));
++  }
++#else
+   EXPECT_EQ(VaapiPictureFactory::kVaapiImplementationDrm,
+             mock_vaapi_picture_factory_->GetVaapiImplementation(
+                 gl::kGLImplementationEGLANGLE));
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.cc	2023-04-14 21:29:41.777328062 +0200
+@@ -62,7 +62,7 @@
+ #include "ui/gl/gl_bindings.h"
+ #include "ui/gl/gl_implementation.h"
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ typedef XID Drawable;
+ 
+ extern "C" {
+@@ -70,7 +70,7 @@ extern "C" {
+ }
+ 
+ #include "ui/gfx/x/connection.h"  // nogncheck
+-#endif                            // BUILDFLAG(USE_VAAPI_X11)
++#endif                            // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ #if BUILDFLAG(IS_OZONE)
+ #include "ui/ozone/public/ozone_platform.h"
+@@ -84,14 +84,14 @@ using media_gpu_vaapi::kModuleVa_prot;
+ 
+ using media_gpu_vaapi::kModuleVa;
+ using media_gpu_vaapi::kModuleVa_drm;
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::kModuleVa_x11;
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::InitializeStubs;
+ using media_gpu_vaapi::IsVaInitialized;
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::IsVa_x11Initialized;
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ using media_gpu_vaapi::IsVa_drmInitialized;
+ using media_gpu_vaapi::StubPathMap;
+ 
+@@ -680,6 +680,12 @@ class VADisplayState {
+ 
+   void SetDrmFd(base::PlatformFile fd) { drm_fd_.reset(HANDLE_EINTR(dup(fd))); }
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  absl::optional<bool> MayUseVaapiOverX11() const {
++    return may_use_vaapi_over_x11_;
++  }
++#endif
++
+  private:
+   friend class base::NoDestructor<VADisplayState>;
+ 
+@@ -702,6 +708,13 @@ class VADisplayState {
+   // Drm fd used to obtain access to the driver interface by VA.
+   base::ScopedFD drm_fd_;
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  // Whether we'll be possibly using VA-API over Ozone/X11. This should only be
++  // set (if at all) during the pre-sandbox initialization. If absl::nullopt,
++  // all calls to Initialize() will return false immediately.
++  absl::optional<bool> may_use_vaapi_over_x11_;
++#endif
++
+   // The VADisplay handle. Valid between Initialize() and Deinitialize().
+   VADisplay va_display_;
+ 
+@@ -723,6 +736,15 @@ VADisplayState* VADisplayState::Get() {
+ 
+ // static
+ void VADisplayState::PreSandboxInitialization() {
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  if (ui::OzonePlatform::IsInitialized()) {
++    VADisplayState::Get()->may_use_vaapi_over_x11_ =
++        ui::OzonePlatform::GetInstance()
++            ->GetPlatformProperties()
++            .supports_vaapi_x11;
++  }
++#endif
++
+   constexpr char kRenderNodeFilePattern[] = "/dev/dri/renderD%d";
+   // This loop ends on either the first card that does not exist or the first
+   // render node that is not vgem.
+@@ -755,20 +777,18 @@ VADisplayState::VADisplayState()
+ bool VADisplayState::Initialize() {
+   base::AutoLock auto_lock(va_lock_);
+ 
+-#if BUILDFLAG(IS_OZONE) && BUILDFLAG(IS_LINUX)
+-  // TODO(crbug.com/1116701): add vaapi support for other Ozone platforms on
+-  // Linux. See comment in OzonePlatform::PlatformProperties::supports_vaapi
+-  // for more details. This will also require revisiting everything that's
+-  // guarded by USE_VAAPI_X11. For example, if USE_VAAPI_X11 is true, but the
+-  // user chooses the Wayland backend for Ozone at runtime, then many things (if
+-  // not all) that we do for X11 won't apply.
+-  if (!ui::OzonePlatform::GetInstance()->GetPlatformProperties().supports_vaapi)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  if (!may_use_vaapi_over_x11_.has_value())
+     return false;
+ #endif
+ 
+   bool libraries_initialized = IsVaInitialized() && IsVa_drmInitialized();
+-#if BUILDFLAG(USE_VAAPI_X11)
+-  libraries_initialized = libraries_initialized && IsVa_x11Initialized();
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  // Initialize VA-API X11 display backend for Linux Ozone/X11.
++  // See comment in OzonePlatform::PlatformProperties::supports_vaapi_x11 for
++  // more details.
++  if (may_use_vaapi_over_x11_.value())
++    libraries_initialized = libraries_initialized && IsVa_x11Initialized();
+ #endif
+   if (!libraries_initialized)
+     return false;
+@@ -783,7 +803,7 @@ bool VADisplayState::Initialize() {
+   return success;
+ }
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ absl::optional<VADisplay> GetVADisplayStateX11(const base::ScopedFD& drm_fd) {
+   switch (gl::GetGLImplementation()) {
+@@ -809,13 +829,19 @@ absl::optional<VADisplay> GetVADisplaySt
+   }
+ }
+ 
+-#else
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ absl::optional<VADisplay> GetVADisplayState(const base::ScopedFD& drm_fd) {
+   switch (gl::GetGLImplementation()) {
+     case gl::kGLImplementationEGLGLES2:
++#if BUILDFLAG(IS_CHROMEOS)
++    // GetVADisplayState() should not get called on Linux with Ozone/X11
++    // (GetVADisplayStateX11() should get called instead), and we haven't tried
++    // VA-API decoding on Linux with Ozone/Wayland and anything other than
++    // native EGL/GLES2.
+     case gl::kGLImplementationEGLANGLE:
+     case gl::kGLImplementationNone:
++#endif
+       return vaGetDisplayDRM(drm_fd.get());
+     default:
+       LOG(WARNING) << "VAAPI video acceleration not available for "
+@@ -825,18 +851,23 @@ absl::optional<VADisplay> GetVADisplaySt
+   }
+ }
+ 
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
+-
+ bool VADisplayState::InitializeVaDisplay_Locked() {
+-  absl::optional<VADisplay> display =
+-#if BUILDFLAG(USE_VAAPI_X11)
+-      GetVADisplayStateX11(drm_fd_);
+-#else
+-      GetVADisplayState(drm_fd_);
+-#endif
++  absl::optional<VADisplay> display;
+ 
+-  if (!display)
+-    return false;
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  DCHECK(may_use_vaapi_over_x11_.has_value());
++  if (may_use_vaapi_over_x11_.value()) {
++    display = GetVADisplayStateX11(drm_fd_);
++    if (!display)
++      return false;
++  }
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++
++  if (!display) {
++    display = GetVADisplayState(drm_fd_);
++    if (!display)
++      return false;
++  }
+ 
+   va_display_ = *display;
+   if (!vaDisplayIsValid(va_display_)) {
+@@ -1671,6 +1702,13 @@ scoped_refptr<VaapiWrapper> VaapiWrapper
+                 enforce_sequence_affinity);
+ }
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++// static
++absl::optional<bool> VaapiWrapper::MayUseVaapiOverX11() {
++  return VADisplayState::Get()->MayUseVaapiOverX11();
++}
++#endif
++
+ // static
+ std::vector<SVCScalabilityMode> VaapiWrapper::GetSupportedScalabilityModes(
+     VideoCodecProfile media_profile,
+@@ -2684,12 +2722,13 @@ bool VaapiWrapper::MapAndCopyAndExecute(
+   return Execute_Locked(va_surface_id, va_buffer_ids);
+ }
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ bool VaapiWrapper::PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+                                         x11::Pixmap x_pixmap,
+                                         gfx::Size dest_size) {
+   CHECK(!enforce_sequence_affinity_ ||
+         sequence_checker_.CalledOnValidSequence());
++  CHECK(MayUseVaapiOverX11().value_or(false));
+   base::AutoLockMaybe auto_lock(va_lock_.get());
+ 
+   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
+@@ -2703,7 +2742,7 @@ bool VaapiWrapper::PutSurfaceIntoPixmap(
+   VA_SUCCESS_OR_RETURN(va_res, VaapiFunctions::kVAPutSurface, false);
+   return true;
+ }
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ std::unique_ptr<ScopedVAImage> VaapiWrapper::CreateVaImage(
+     VASurfaceID va_surface_id,
+@@ -3105,7 +3144,7 @@ void VaapiWrapper::PreSandboxInitializat
+ 
+   paths[kModuleVa].push_back(std::string("libva.so.") + va_suffix);
+   paths[kModuleVa_drm].push_back(std::string("libva-drm.so.") + va_suffix);
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+   paths[kModuleVa_x11].push_back(std::string("libva-x11.so.") + va_suffix);
+ #endif
+ #if BUILDFLAG(IS_CHROMEOS_ASH)
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h
+--- chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/vaapi_wrapper.h	2023-04-14 21:29:41.777328062 +0200
+@@ -36,9 +36,9 @@
+ #include "third_party/abseil-cpp/absl/types/optional.h"
+ #include "ui/gfx/geometry/size.h"
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include "ui/gfx/x/xproto.h"  // nogncheck
+-#endif                        // BUILDFLAG(USE_VAAPI_X11)
++#endif                        // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ namespace gfx {
+ enum class BufferFormat;
+@@ -186,6 +186,16 @@ class MEDIA_GPU_EXPORT VaapiWrapper
+   VaapiWrapper(const VaapiWrapper&) = delete;
+   VaapiWrapper& operator=(const VaapiWrapper&) = delete;
+ 
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
++  // Returns true if VaapiWrapper instances may use VA-API over X11 and false
++  // otherwise (VA-API over DRM will be used). If this returns absl::nullopt,
++  // it's because it was not possible to determine how VA-API may be used. This
++  // should only be called after PreSandboxInitialization() (which is assumed to
++  // be called only once during the GPU process startup) and is safe to call
++  // from any thread. Additionally, this should always return the same value.
++  static absl::optional<bool> MayUseVaapiOverX11();
++#endif
++
+   // Returns the supported SVC scalability modes for specified profile.
+   static std::vector<SVCScalabilityMode> GetSupportedScalabilityModes(
+       VideoCodecProfile media_profile,
+@@ -439,13 +449,13 @@ class MEDIA_GPU_EXPORT VaapiWrapper
+       VASurfaceID va_surface_id,
+       const std::vector<std::pair<VABufferID, VABufferDescriptor>>& va_buffers);
+ 
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+   // Put data from |va_surface_id| into |x_pixmap| of size
+   // |dest_size|, converting/scaling to it.
+   [[nodiscard]] bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+                                           x11::Pixmap x_pixmap,
+                                           gfx::Size dest_size);
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+   // Creates a ScopedVAImage from a VASurface |va_surface_id| and map it into
+   // memory with the given |format| and |size|. If |format| is not equal to the
+diff -up chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment
+--- chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment.wayland-vaapi	2023-03-30 02:33:53.000000000 +0200
++++ chromium-112.0.5615.49/media/gpu/vaapi/va_stub_header.fragment	2023-04-14 21:29:41.777328062 +0200
+@@ -7,8 +7,8 @@ extern "C" {
+ 
+ #include <va/va_drm.h>
+ #include <va/va.h>
+-#if BUILDFLAG(USE_VAAPI_X11)
++#if BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ #include <va/va_x11.h>
+-#endif  // BUILDFLAG(USE_VAAPI_X11)
++#endif  // BUILDFLAG(SUPPORT_VAAPI_OVER_X11)
+ 
+ }
+diff -up chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc
+--- chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc.wayland-vaapi	2023-03-30 02:34:19.000000000 +0200
++++ chromium-112.0.5615.49/ui/ozone/platform/x11/ozone_platform_x11.cc	2023-04-14 21:29:41.778328082 +0200
+@@ -197,7 +197,7 @@ class OzonePlatformX11 : public OzonePla
+       properties->app_modal_dialogs_use_event_blocker = true;
+       properties->fetch_buffer_formats_for_gmb_on_gpu = true;
+ #if BUILDFLAG(IS_LINUX)
+-      properties->supports_vaapi = true;
++      properties->supports_vaapi_x11 = true;
+ #endif
+ 
+       initialised = true;
+diff -up chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h.wayland-vaapi chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h
+--- chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h.wayland-vaapi	2023-03-30 02:34:19.000000000 +0200
++++ chromium-112.0.5615.49/ui/ozone/public/ozone_platform.h	2023-04-14 21:29:41.778328082 +0200
+@@ -145,12 +145,13 @@ class COMPONENT_EXPORT(OZONE) OzonePlatf
+     bool fetch_buffer_formats_for_gmb_on_gpu = false;
+ 
+ #if BUILDFLAG(IS_LINUX)
+-    // TODO(crbug.com/1116701): add vaapi support for other Ozone platforms on
+-    // Linux. At the moment, VA-API Linux implementation supports only X11
+-    // backend. This implementation must be refactored to support Ozone
+-    // properly. As a temporary solution, VA-API on Linux checks if vaapi is
+-    // supported (which implicitly means that it is Ozone/X11).
+-    bool supports_vaapi = false;
++    // VA-API supports different display backends.
++    // See https://github.com/intel/libva/blob/master/va/va_backend.h
++    //
++    // VA/DRM and VA/X11 are used by Chromium at the moment. All Ozone platforms
++    // support VA/DRM by default. `supports_vaapi_x11` indicates if VA/X11
++    // supported; it is true only on Ozone/X11 platform.
++    bool supports_vaapi_x11 = false;
+ #endif
+ 
+     // Indicates that the platform allows client applications to manipulate

chromium.spec

@@ -362,6 +362,9 @@ Patch150: chromium-124-qt6.patch
 Patch305: chromium-124-el8-arm64-memory_tagging.patch
 Patch306: chromium-127-el8-ifunc-header.patch
 
+# workaround for build error due to old atk version on el8
+Patch307: chromium-129-el8-atk-compiler-error.patch
+
 # enable fstack-protector-strong
 Patch312: chromium-123-fstack-protector-strong.patch
 
@@ -1084,6 +1087,7 @@ Qt6 UI for chromium.
 %patch -P305 -p1 -b .el8-memory_tagging
 %patch -P306 -p1 -b .el8-ifunc-header
 %endif
+%patch -P307 -p1 -b .el8-atk-compiler-error
 %endif
 
 %patch -P312 -p1 -b .fstack-protector-strong