diff options
Diffstat (limited to 'recipes-wam/cef/files/chromium')
9 files changed, 2982 insertions, 0 deletions
diff --git a/recipes-wam/cef/files/chromium/0001-sql-relax-constraints-on-VirtualCursor-layout.patch b/recipes-wam/cef/files/chromium/0001-sql-relax-constraints-on-VirtualCursor-layout.patch new file mode 100644 index 000000000..624dd5019 --- /dev/null +++ b/recipes-wam/cef/files/chromium/0001-sql-relax-constraints-on-VirtualCursor-layout.patch @@ -0,0 +1,51 @@ +From 94ffefa81d00466fabcf1050080c95fa4b294dda Mon Sep 17 00:00:00 2001 +From: Elly Fong-Jones <ellyjones@chromium.org> +Date: Thu, 2 Mar 2023 00:15:11 +0000 +Subject: [PATCH 1/9] sql: relax constraints on VirtualCursor layout + +VirtualCursor::FromSqliteCursor required that VirtualCursor had a +standard layout, but in fact VirtualCursor shouldn't have a standard +layout, and the fact that it does with libc++ is a deviation from the +C++ standard. This change: + +1. Relaxes the requirement that VirtualCursor has a standard layout, and +2. Relaxes the requirement that the sqlite_cursor_ field has to be at + offset 0 + +by use of offsetof() and pointer subtraction. This change both improves +standards compliance and makes this code build with libstdc++. + +Bug: 1380656 +Change-Id: I9c47abd9197b187da0360ca5619ccf7dadab4f33 +Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4292313 +Reviewed-by: Austin Sullivan <asully@chromium.org> +Commit-Queue: Elly Fong-Jones <ellyjones@chromium.org> +Cr-Commit-Position: refs/heads/main@{#1111925} +--- + sql/recover_module/cursor.h | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +diff --git a/sql/recover_module/cursor.h b/sql/recover_module/cursor.h +index 1970bdca8c6f1..4cb0655700977 100644 +--- a/sql/recover_module/cursor.h ++++ b/sql/recover_module/cursor.h +@@ -63,12 +63,10 @@ class VirtualCursor { + // |sqlite_cursor| must have been returned by VirtualTable::SqliteCursor(). + static inline VirtualCursor* FromSqliteCursor( + sqlite3_vtab_cursor* sqlite_cursor) { +- static_assert(std::is_standard_layout<VirtualCursor>::value, +- "needed for the reinterpret_cast below"); +- static_assert(offsetof(VirtualCursor, sqlite_cursor_) == 0, +- "sqlite_cursor_ must be the first member of the class"); +- VirtualCursor* result = reinterpret_cast<VirtualCursor*>(sqlite_cursor); +- DCHECK_EQ(sqlite_cursor, &result->sqlite_cursor_); ++ VirtualCursor* result = reinterpret_cast<VirtualCursor*>( ++ (reinterpret_cast<char*>(sqlite_cursor) - ++ offsetof(VirtualCursor, sqlite_cursor_))); ++ CHECK_EQ(sqlite_cursor, &result->sqlite_cursor_); + return result; + } + +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0002-Don-t-look-for-depot_tools-in-chrommium-s-third_part.patch b/recipes-wam/cef/files/chromium/0002-Don-t-look-for-depot_tools-in-chrommium-s-third_part.patch new file mode 100644 index 000000000..dd05b3730 --- /dev/null +++ b/recipes-wam/cef/files/chromium/0002-Don-t-look-for-depot_tools-in-chrommium-s-third_part.patch @@ -0,0 +1,32 @@ +From dd5ce9e0d0dbf55184a9c57c4c81eeaf9a7dd3a9 Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Fri, 7 Apr 2023 16:28:51 +0200 +Subject: [PATCH 2/9] Don't look for depot_tools in chrommium's third_party + folder + +--- + build/find_depot_tools.py | 8 -------- + 1 file changed, 8 deletions(-) + +diff --git a/build/find_depot_tools.py b/build/find_depot_tools.py +index 94985fe7b3495..6d2adcfa63531 100755 +--- a/build/find_depot_tools.py ++++ b/build/find_depot_tools.py +@@ -28,14 +28,6 @@ def IsRealDepotTools(path): + + def add_depot_tools_to_path(): + """Search for depot_tools and add it to sys.path.""" +- # First, check if we have a DEPS'd in "depot_tools". +- deps_depot_tools = os.path.join(SRC, 'third_party', 'depot_tools') +- if IsRealDepotTools(deps_depot_tools): +- # Put the pinned version at the start of the sys.path, in case there +- # are other non-pinned versions already on the sys.path. +- sys.path.insert(0, deps_depot_tools) +- return deps_depot_tools +- + # Then look if depot_tools is already in PYTHONPATH. + for i in sys.path: + if i.rstrip(os.sep).endswith('depot_tools') and IsRealDepotTools(i): +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0003-Remove-the-GN-settings-done-for-clang-that-conflict-.patch b/recipes-wam/cef/files/chromium/0003-Remove-the-GN-settings-done-for-clang-that-conflict-.patch new file mode 100644 index 000000000..68c37f25a --- /dev/null +++ b/recipes-wam/cef/files/chromium/0003-Remove-the-GN-settings-done-for-clang-that-conflict-.patch @@ -0,0 +1,116 @@ +From 22de50ac2371aed1e04e4cb248beabb7f8ad3ebe Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Thu, 27 Apr 2023 16:16:28 +0200 +Subject: [PATCH 3/9] Remove the GN settings done for clang that conflict with + OE + +clang cross compiler that is build with meta-clang has lot of these +settings built-in and specifying them here confuses the compiler + +--target option and -no-canonical-prefixes options result in clang + +finding the headers in target sysroot + +Upstream-Status: Inappropriate [OE-Specific] + +Signed-off-by: Khem Raj <raj.khem@gmail.com> +Rebased-by: Maksim Sisov <msisov@igalia.com> +Rebased-by: Randy MacLeod <randy.macleod@windriver.com> +Rebased-by: Roger Zanoni <rzanoni@igalia.com> +--- + build/config/compiler/BUILD.gn | 37 ---------------------------------- + 1 file changed, 37 deletions(-) + +diff --git a/build/config/compiler/BUILD.gn b/build/config/compiler/BUILD.gn +index 531b326c498d0..244a6757613d5 100644 +--- a/build/config/compiler/BUILD.gn ++++ b/build/config/compiler/BUILD.gn +@@ -924,11 +924,6 @@ config("compiler_cpu_abi") { + ] + } + } else if (current_cpu == "arm") { +- if (is_clang && !is_android && !is_nacl && +- !(is_chromeos_lacros && is_chromeos_device)) { +- cflags += [ "--target=arm-linux-gnueabihf" ] +- ldflags += [ "--target=arm-linux-gnueabihf" ] +- } + if (!is_nacl) { + cflags += [ + "-march=$arm_arch", +@@ -939,11 +934,6 @@ config("compiler_cpu_abi") { + cflags += [ "-mtune=$arm_tune" ] + } + } else if (current_cpu == "arm64") { +- if (is_clang && !is_android && !is_nacl && !is_fuchsia && +- !(is_chromeos_lacros && is_chromeos_device)) { +- cflags += [ "--target=aarch64-linux-gnu" ] +- ldflags += [ "--target=aarch64-linux-gnu" ] +- } + if (is_android) { + # Outline atomics crash on Exynos 9810. http://crbug.com/1272795 + cflags += [ "-mno-outline-atomics" ] +@@ -955,9 +945,6 @@ config("compiler_cpu_abi") { + if (is_android) { + cflags += [ "--target=mipsel-linux-android" ] + ldflags += [ "--target=mipsel-linux-android" ] +- } else { +- cflags += [ "--target=mipsel-linux-gnu" ] +- ldflags += [ "--target=mipsel-linux-gnu" ] + } + } else { + cflags += [ "-EL" ] +@@ -1037,8 +1024,6 @@ config("compiler_cpu_abi") { + ldflags += [ "-Wl,--hash-style=sysv" ] + if (custom_toolchain == "") { + if (is_clang) { +- cflags += [ "--target=mips-linux-gnu" ] +- ldflags += [ "--target=mips-linux-gnu" ] + } else { + cflags += [ "-EB" ] + ldflags += [ "-EB" ] +@@ -1086,9 +1071,6 @@ config("compiler_cpu_abi") { + if (is_android) { + cflags += [ "--target=mips64el-linux-android" ] + ldflags += [ "--target=mips64el-linux-android" ] +- } else { +- cflags += [ "--target=mips64el-linux-gnuabi64" ] +- ldflags += [ "--target=mips64el-linux-gnuabi64" ] + } + } else { + cflags += [ +@@ -1146,8 +1128,6 @@ config("compiler_cpu_abi") { + ldflags += [ "-Wl,--hash-style=sysv" ] + if (custom_toolchain == "") { + if (is_clang) { +- cflags += [ "--target=mips64-linux-gnuabi64" ] +- ldflags += [ "--target=mips64-linux-gnuabi64" ] + } else { + cflags += [ + "-EB", +@@ -1309,23 +1289,6 @@ config("compiler_deterministic") { + } + } + } +- +- # Tells the compiler not to use absolute paths when passing the default +- # paths to the tools it invokes. We don't want this because we don't +- # really need it and it can mess up the goma cache entries. +- if (is_clang && (!is_nacl || is_nacl_saigo)) { +- cflags += [ "-no-canonical-prefixes" ] +- +- # Same for links: Let the compiler driver invoke the linker +- # with a relative path and pass relative paths to built-in +- # libraries. Not needed on Windows because we call the linker +- # directly there, not through the compiler driver. +- # We don't link on goma, so this change is just for cleaner +- # internal linker invocations, for people who work on the build. +- if (!is_win) { +- ldflags += [ "-no-canonical-prefixes" ] +- } +- } + } + + config("clang_revision") { +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0004-Don-t-use-DRI-for-renesas.patch b/recipes-wam/cef/files/chromium/0004-Don-t-use-DRI-for-renesas.patch new file mode 100644 index 000000000..332e1f2de --- /dev/null +++ b/recipes-wam/cef/files/chromium/0004-Don-t-use-DRI-for-renesas.patch @@ -0,0 +1,42 @@ +From 60b8b1379f2eb154a3c58c00dabbf0f9f0bd5445 Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Thu, 4 May 2023 10:42:06 +0200 +Subject: [PATCH 4/9] Don't use DRI for renesas + +This adds the use_dri flag that defauls to true and +can be disabled if we are building CEF using ozone + wayland + +Signed-off-by: Roger Zanoni <rzanoni@igalia.com> +--- + content/gpu/BUILD.gn | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/content/gpu/BUILD.gn b/content/gpu/BUILD.gn +index 9f5f303b2f220..f7639030ac30c 100644 +--- a/content/gpu/BUILD.gn ++++ b/content/gpu/BUILD.gn +@@ -8,6 +8,10 @@ import("//build/config/ui.gni") + import("//gpu/vulkan/features.gni") + import("//media/media_options.gni") + ++declare_args() { ++ use_dri = true ++} ++ + # See //content/BUILD.gn for how this works. + group("gpu") { + visibility = [ "//content/*" ] # This is an internal content API. +@@ -137,8 +141,8 @@ target(link_target_type, "gpu_sources") { + } + + # Use DRI on desktop Linux builds. +- if (current_cpu != "s390x" && current_cpu != "ppc64" && is_linux && +- !is_castos) { ++ if (use_dri && current_cpu != "s390x" && current_cpu != "ppc64" && ++ is_linux && !is_castos) { + configs += [ "//build/config/linux/dri" ] + } + } +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0005-Add-the-essential-parts-of-wayland-extensions-and-ag.patch b/recipes-wam/cef/files/chromium/0005-Add-the-essential-parts-of-wayland-extensions-and-ag.patch new file mode 100644 index 000000000..fea8c04ac --- /dev/null +++ b/recipes-wam/cef/files/chromium/0005-Add-the-essential-parts-of-wayland-extensions-and-ag.patch @@ -0,0 +1,912 @@ +From 7e927a21ecaa70c14873d5f06667dfc3bdaa4d25 Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Mon, 15 May 2023 20:32:06 +0200 +Subject: [PATCH 5/9] Add the essential parts of wayland extensions and + agl_shell + +--- + ui/base/ui_base_switches.cc | 2 + + ui/base/ui_base_switches.h | 3 + + ui/ozone/platform/wayland/BUILD.gn | 7 + + .../platform/wayland/extensions/agl/BUILD.gn | 40 ++++ + .../agl/common/wayland_object_agl.cc | 26 +++ + .../agl/common/wayland_object_agl.h | 34 ++++ + .../extensions/agl/host/agl_shell_wrapper.cc | 113 +++++++++++ + .../extensions/agl/host/agl_shell_wrapper.h | 62 ++++++ + .../agl/host/wayland_extensions_agl.h | 37 ++++ + .../agl/host/wayland_extensions_agl_impl.cc | 93 +++++++++ + .../agl/host/wayland_extensions_agl_impl.h | 54 ++++++ + .../extensions/agl/protocol/agl-shell.xml | 179 ++++++++++++++++++ + .../wayland/host/wayland_connection.cc | 12 +- + .../wayland/host/wayland_connection.h | 6 + + .../wayland/host/wayland_extensions.h | 56 ++++++ + 15 files changed, 722 insertions(+), 2 deletions(-) + create mode 100644 ui/ozone/platform/wayland/extensions/agl/BUILD.gn + create mode 100644 ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.cc + create mode 100644 ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h + create mode 100644 ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml + create mode 100644 ui/ozone/platform/wayland/host/wayland_extensions.h + +diff --git a/ui/base/ui_base_switches.cc b/ui/base/ui_base_switches.cc +index f8556679a79d8..e72ae83737c04 100644 +--- a/ui/base/ui_base_switches.cc ++++ b/ui/base/ui_base_switches.cc +@@ -100,4 +100,6 @@ const char kUIDisablePartialSwap[] = "ui-disable-partial-swap"; + // Enables the ozone x11 clipboard for linux-chromeos. + const char kUseSystemClipboard[] = "use-system-clipboard"; + ++const char kAglShellAppId[] = "agl-shell-appid"; ++ + } // namespace switches +diff --git a/ui/base/ui_base_switches.h b/ui/base/ui_base_switches.h +index d35e544f2bc2f..019ba0e5151e5 100644 +--- a/ui/base/ui_base_switches.h ++++ b/ui/base/ui_base_switches.h +@@ -45,6 +45,9 @@ COMPONENT_EXPORT(UI_BASE) extern const char kTopChromeTouchUiEnabled[]; + COMPONENT_EXPORT(UI_BASE) extern const char kUIDisablePartialSwap[]; + COMPONENT_EXPORT(UI_BASE) extern const char kUseSystemClipboard[]; + ++// Agl related ++COMPONENT_EXPORT(UI_BASE) extern const char kAglShellAppId[]; ++ + // Test related. + COMPONENT_EXPORT(UI_BASE) extern const char kDisallowNonExactResourceReuse[]; + COMPONENT_EXPORT(UI_BASE) extern const char kMangleLocalizedStrings[]; +diff --git a/ui/ozone/platform/wayland/BUILD.gn b/ui/ozone/platform/wayland/BUILD.gn +index e0f0d7dea3747..1a2f889dc8947 100644 +--- a/ui/ozone/platform/wayland/BUILD.gn ++++ b/ui/ozone/platform/wayland/BUILD.gn +@@ -407,6 +407,13 @@ source_set("wayland") { + ] + } + ++ sources += [ ++ "host/wayland_extensions.h", ++ "host/wayland_extensions_stub.cc", ++ ] ++ ++ deps += [ "extensions/agl" ] ++ + configs += [ "//third_party/khronos:khronos_headers" ] + } + +diff --git a/ui/ozone/platform/wayland/extensions/agl/BUILD.gn b/ui/ozone/platform/wayland/extensions/agl/BUILD.gn +new file mode 100644 +index 0000000000000..ce289bc5dbbca +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/BUILD.gn +@@ -0,0 +1,40 @@ ++# Copyright 2021 LG Electronics, Inc. ++# ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# http://www.apache.org/licenses/LICENSE-2.0 ++# ++# Unless required by applicable law or agreed to in writing, software ++# distributed under the License is distributed on an "AS IS" BASIS, ++# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++# See the License for the specific language governing permissions and ++# limitations under the License. ++# ++# SPDX-License-Identifier: Apache-2.0 ++ ++import("//third_party/wayland/wayland_protocol.gni") ++ ++visibility = [ "//ui/ozone/*" ] ++ ++wayland_protocol("agl_shell_protocol") { ++ sources = [ "protocol/agl-shell.xml" ] ++} ++ ++source_set("agl") { ++ sources = [ ++ "common/wayland_object_agl.cc", ++ "common/wayland_object_agl.h", ++ "host/agl_shell_wrapper.cc", ++ "host/agl_shell_wrapper.h", ++ "host/wayland_extensions_agl.h", ++ "host/wayland_extensions_agl_impl.cc", ++ "host/wayland_extensions_agl_impl.h", ++ ] ++ ++ deps = [ ++ ":agl_shell_protocol", ++ "//ui/ozone/platform/wayland/mojom", ++ ] ++} +diff --git a/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.cc b/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.cc +new file mode 100644 +index 0000000000000..9f3300766df2c +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.cc +@@ -0,0 +1,26 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#include "ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h" ++ ++#include <agl-shell-client-protocol.h> ++ ++namespace wl { ++ ++const wl_interface* ObjectTraits<agl_shell>::interface = &agl_shell_interface; ++void (*ObjectTraits<agl_shell>::deleter)(agl_shell*) = &agl_shell_destroy; ++ ++} // namespace wl +\ No newline at end of file +diff --git a/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h b/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h +new file mode 100644 +index 0000000000000..e91ac0da8d2fc +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h +@@ -0,0 +1,34 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_COMMON_WAYLAND_OBJECT_AGL_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_COMMON_WAYLAND_OBJECT_AGL_H_ ++ ++#include "ui/ozone/platform/wayland/common/wayland_object.h" ++ ++struct agl_shell; ++ ++namespace wl { ++ ++template <> ++struct ObjectTraits<agl_shell> { ++ static const wl_interface* interface; ++ static void (*deleter)(agl_shell*); ++}; ++ ++} // namespace wl ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_COMMON_WAYLAND_OBJECT_AGL_H_ +\ No newline at end of file +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc +new file mode 100644 +index 0000000000000..c74fa5d9cd221 +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc +@@ -0,0 +1,113 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#include "ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h" ++ ++#include "agl_shell_wrapper.h" ++#include "base/logging.h" ++#include "ui/base/ui_base_switches.h" ++#include "ui/ozone/platform/wayland/host/wayland_connection.h" ++#include "ui/ozone/platform/wayland/host/wayland_output_manager.h" ++#include "ui/ozone/platform/wayland/host/wayland_window.h" ++ ++namespace ui { ++ ++static const struct agl_shell_listener shell_listener = { ++ &AglShellWrapper::AglShellBoundOk, ++ &AglShellWrapper::AglShellBoundFail, ++#ifdef AGL_SHELL_APP_STATE_SINCE_VERSION ++ &AglShellWrapper::AglAppState, ++#endif ++}; ++ ++AglShellWrapper::AglShellWrapper(agl_shell* agl_shell, ++ WaylandConnection* wayland_connection) ++ : agl_shell_(agl_shell), connection_(wayland_connection) { ++ if (wl::get_version_of_object(agl_shell) >= AGL_SHELL_BOUND_OK_SINCE_VERSION) ++ agl_shell_add_listener(agl_shell, &shell_listener, this); ++} ++ ++AglShellWrapper::~AglShellWrapper() = default; ++ ++void AglShellWrapper::SetAglActivateApp(const std::string& app_id) { ++ wl_output* output = ++ connection_->wayland_output_manager()->GetPrimaryOutput()->get_output(); ++ agl_shell_activate_app(agl_shell_.get(), app_id.c_str(), output); ++} ++ ++void AglShellWrapper::SetAglPanel(WaylandWindow* window, uint32_t edge) { ++ wl_surface* surface = window->root_surface()->surface(); ++ wl_output* output = ++ connection_->wayland_output_manager()->GetPrimaryOutput()->get_output(); ++ ++ agl_shell_set_panel(agl_shell_.get(), surface, output, edge); ++} ++ ++void AglShellWrapper::SetAglBackground(WaylandWindow* window) { ++ wl_surface* surface = window->root_surface()->surface(); ++ wl_output* output = ++ connection_->wayland_output_manager()->GetPrimaryOutput()->get_output(); ++ ++ agl_shell_set_background(agl_shell_.get(), surface, output); ++} ++ ++void AglShellWrapper::SetAglReady() { ++ agl_shell_ready(agl_shell_.get()); ++} ++ ++// static ++void AglShellWrapper::AglShellBoundOk(void* data, struct agl_shell*) { ++ AglShellWrapper* wrapper = static_cast<AglShellWrapper*>(data); ++ wrapper->wait_for_bound_ = false; ++ wrapper->bound_ok_ = true; ++ LOG(INFO) << "Bound to agl_shell (bound_ok)"; ++} ++ ++// static ++void AglShellWrapper::AglShellBoundFail(void* data, struct agl_shell*) { ++ AglShellWrapper* wrapper = static_cast<AglShellWrapper*>(data); ++ wrapper->wait_for_bound_ = false; ++ wrapper->bound_ok_ = false; ++ LOG(INFO) << "Failed to bind to agl_shell (bound_fail)"; ++} ++ ++#ifdef AGL_SHELL_APP_STATE_SINCE_VERSION ++// static ++void AglShellWrapper::AglAppState(void* data, ++ struct agl_shell*, ++ const char* app_id, ++ uint32_t state) { ++ AglShellWrapper* wrapper = static_cast<AglShellWrapper*>(data); ++ ++ LOG(INFO) << "State for app " << app_id << " changed to " << state; ++ ++ if (state == AGL_SHELL_APP_STATE_STARTED) { ++ wrapper->SetAglActivateApp(app_id); ++ LOG(INFO) << "Activating app " << app_id; ++ } ++} ++#endif ++ ++bool AglShellWrapper::WaitUntilBoundOk() { ++ int ret = 0; ++ while (ret != -1 && wait_for_bound_) { ++ ret = wl_display_dispatch(connection_->display()); ++ } ++ ++ return bound_ok_; ++} ++ ++} // namespace ui +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h +new file mode 100644 +index 0000000000000..2ab765883057e +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h +@@ -0,0 +1,62 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_AGL_SHELL_WRAPPER_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_AGL_SHELL_WRAPPER_H_ ++ ++#include <string> ++ ++#include <agl-shell-client-protocol.h> ++ ++#include "ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h" ++ ++namespace ui { ++ ++class WaylandConnection; ++class WaylandWindow; ++ ++class AglShellWrapper { ++ public: ++ AglShellWrapper(agl_shell* agl_shell, WaylandConnection* wayland_connection); ++ AglShellWrapper(const AglShellWrapper&) = delete; ++ AglShellWrapper& operator=(const AglShellWrapper&) = delete; ++ ~AglShellWrapper(); ++ ++ void SetAglActivateApp(const std::string& app_id); ++ void SetAglPanel(WaylandWindow* window, uint32_t edge); ++ void SetAglBackground(WaylandWindow* window); ++ void SetAglReady(); ++ bool WaitUntilBoundOk(); ++ ++ static void AglShellBoundOk(void* data, struct agl_shell*); ++ static void AglShellBoundFail(void* data, struct agl_shell*); ++#ifdef AGL_SHELL_APP_STATE_SINCE_VERSION ++ static void AglAppState(void* data, ++ struct agl_shell*, ++ const char* app_id, ++ uint32_t state); ++#endif ++ ++ private: ++ wl::Object<agl_shell> agl_shell_; ++ WaylandConnection* connection_; ++ bool wait_for_bound_ = true; ++ bool bound_ok_ = false; ++}; ++ ++} // namespace ui ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_AGL_SHELL_WRAPPER_H_ +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h +new file mode 100644 +index 0000000000000..df42fc00c84da +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h +@@ -0,0 +1,37 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_H_ ++ ++namespace ui { ++ ++class AglShellWrapper; ++ ++// AGL extensions implementation for webOS/Lite ++class WaylandExtensionsAgl { ++ public: ++ WaylandExtensionsAgl() = default; ++ WaylandExtensionsAgl(const WaylandExtensionsAgl&) = delete; ++ WaylandExtensionsAgl& operator=(const WaylandExtensionsAgl&) = delete; ++ virtual ~WaylandExtensionsAgl() = default; ++ ++ virtual AglShellWrapper* GetAglShell() = 0; ++}; ++ ++} // namespace ui ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_H_ +\ No newline at end of file +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +new file mode 100644 +index 0000000000000..26a5f0550c302 +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +@@ -0,0 +1,93 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#include "ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h" ++ ++#include <cstring> ++ ++#include "base/command_line.h" ++#include "base/logging.h" ++#include "ui/base/ui_base_switches.h" ++#include "ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h" ++#include "ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h" ++#include "ui/ozone/platform/wayland/host/wayland_connection.h" ++ ++namespace ui { ++ ++namespace { ++ ++constexpr uint32_t kMinAglShellExtensionVersion = 1; ++constexpr uint32_t kMaxAglShellExtensionVersion = 3; ++ ++} // namespace ++ ++WaylandExtensionsAglImpl::WaylandExtensionsAglImpl( ++ WaylandConnection* connection) ++ : connection_(connection) {} ++ ++WaylandExtensionsAglImpl::~WaylandExtensionsAglImpl() = default; ++ ++bool WaylandExtensionsAglImpl::Bind(wl_registry* registry, ++ uint32_t name, ++ const char* interface, ++ uint32_t version) { ++ bool should_use_agl_shell = base::CommandLine::ForCurrentProcess()->HasSwitch( ++ switches::kAglShellAppId); ++ bool can_bind = wl::CanBind(interface, version, kMinAglShellExtensionVersion, ++ kMaxAglShellExtensionVersion); ++ bool is_agl_shell_interface = (strcmp(interface, "agl_shell") == 0); ++ ++ if (!is_agl_shell_interface) { ++ return false; ++ } ++ ++ LOG(INFO) << "should_use_agl_shell: " << should_use_agl_shell << ++ " can_bind: " << can_bind; ++ ++ if (should_use_agl_shell && !agl_shell_ && ++ is_agl_shell_interface && can_bind) { ++ wl::Object<agl_shell> aglshell = wl::Bind<agl_shell>( ++ registry, name, std::min(version, kMaxAglShellExtensionVersion)); ++ if (!aglshell) { ++ LOG(ERROR) << "Failed to bind to agl_shell global"; ++ return false; ++ } ++ agl_shell_ = ++ std::make_unique<AglShellWrapper>(aglshell.release(), connection_); ++ ++ LOG(INFO) << "Waiting until bound..."; ++ return agl_shell_->WaitUntilBoundOk(); ++ } else { ++ LOG(INFO) << "Cant bind."; ++ } ++ ++ return false; ++} ++ ++bool WaylandExtensionsAglImpl::HasShellObject() const { ++ return !!agl_shell_; ++} ++ ++AglShellWrapper* WaylandExtensionsAglImpl::GetAglShell() { ++ return agl_shell_.get(); ++} ++ ++std::unique_ptr<WaylandExtensions> CreateWaylandExtensions( ++ WaylandConnection* connection) { ++ return std::make_unique<WaylandExtensionsAglImpl>(connection); ++} ++ ++} // namespace ui +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h +new file mode 100644 +index 0000000000000..f6cbabe99ed0b +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h +@@ -0,0 +1,54 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_IMPL_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_IMPL_H_ ++ ++#include "ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h" ++#include "ui/ozone/platform/wayland/host/wayland_extensions.h" ++ ++namespace ui { ++ ++class AglShellWrapper; ++ ++// AGL extension implementation for webOS/Lite ++class WaylandExtensionsAglImpl : public WaylandExtensions, ++ public WaylandExtensionsAgl { ++ public: ++ explicit WaylandExtensionsAglImpl(WaylandConnection* connection); ++ WaylandExtensionsAglImpl(const WaylandExtensionsAglImpl&) = delete; ++ WaylandExtensionsAglImpl& operator=(const WaylandExtensionsAglImpl&) = delete; ++ ~WaylandExtensionsAglImpl() override; ++ ++ // WaylandExtensions overrides ++ bool Bind(wl_registry* registry, ++ uint32_t name, ++ const char* interface, ++ uint32_t version) override; ++ ++ bool HasShellObject() const override; ++ ++ // WaylandExtensionsAgl overrides ++ AglShellWrapper* GetAglShell() override; ++ ++ private: ++ std::unique_ptr<AglShellWrapper> agl_shell_; ++ WaylandConnection* connection_; ++}; ++ ++} // namespace ui ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_IMPL_H_ +diff --git a/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml b/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml +new file mode 100644 +index 0000000000000..ad5553d61f189 +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml +@@ -0,0 +1,179 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<protocol name="agl_shell"> ++ <copyright> ++ Copyright © 2019, 2022 Collabora, Ltd. ++ ++ Permission is hereby granted, free of charge, to any person obtaining a ++ copy of this software and associated documentation files (the "Software"), ++ to deal in the Software without restriction, including without limitation ++ the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ and/or sell copies of the Software, and to permit persons to whom the ++ Software is furnished to do so, subject to the following conditions: ++ ++ The above copyright notice and this permission notice (including the next ++ paragraph) shall be included in all copies or substantial portions of the ++ Software. ++ ++ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING ++ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ++ DEALINGS IN THE SOFTWARE. ++ </copyright> ++ <interface name="agl_shell" version="3"> ++ <description summary="user interface for Automotive Grade Linux platform"> ++ Starting with version 2 of the protocol, the client is required to wait ++ for the 'bound_ok' or 'bound_fail' events in order to proceed further. ++ ++ In case the client gets a 'bound_fail' event then it should consider that ++ there's another client already bound to the agl_shell protocol. ++ A client that receives a 'bound_ok' event should consider that there's ++ no other client already bound to the interface and can proceed further. ++ ++ If the client uses an older version of the protocol it will receive ++ automatically an error and the compositor will terminate the connection, ++ if there's another client already bound the interface. ++ ++ If the client receives the 'bound_fail' event and attempts to use the ++ interface further it will receive an error and the compositor will ++ terminate the connection. After the 'bound_fail' event was received the ++ client should call the destructor, which has been added with version 2 ++ of the protocol. The client is free to try at a later point in time to ++ see if it will receive the 'bound_ok' event, but there's no explicit way ++ of finding out when that event will be delivered. ++ It is assumed that it can infer that information through other ++ means/other channels. ++ </description> ++ ++ <enum name="error"> ++ <entry name="invalid_argument" value="0"/> ++ <entry name="background_exists" value="1"/> ++ <entry name="panel_exists" value="2"/> ++ </enum> ++ ++ <enum name="edge"> ++ <entry name="top" value="0"/> ++ <entry name="bottom" value="1"/> ++ <entry name="left" value="2"/> ++ <entry name="right" value="3"/> ++ </enum> ++ ++ <enum name="app_state" since="3"> ++ <entry name="started" value="0"/> ++ <entry name="terminated" value="1"/> ++ <entry name="activated" value="2"/> ++ <entry name="deactivated" value="3"/> ++ </enum> ++ ++ <request name="ready"> ++ <description summary="client is ready to be shown"> ++ Tell the server that this client is ready to be shown. The server ++ will delay presentation during start-up until all shell clients are ++ ready to be shown, and will display a black screen instead. ++ This gives the client an opportunity to set up and configure several ++ surfaces into a coherent interface. ++ ++ The client that binds to this interface must send this request, otherwise ++ they may stall the compositor unnecessarily. ++ ++ If this request is called after the compositor has already finished ++ start-up, no operation is performed. ++ </description> ++ </request> ++ ++ <request name="set_background"> ++ <description summary="set surface as output's background"> ++ Set the surface to act as the background of an output. After this ++ request, the server will immediately send a configure event with ++ the dimensions the client should use to cover the entire output. ++ ++ The surface must have a "desktop" surface role, as supported by ++ libweston-desktop. ++ ++ Only a single surface may be the background for any output. If a ++ background surface already exists, a protocol error is raised. ++ </description> ++ <arg name="surface" type="object" interface="wl_surface"/> ++ <arg name="output" type="object" interface="wl_output"/> ++ </request> ++ ++ <request name="set_panel"> ++ <description summary="set surface as panel"> ++ Set the surface to act as a panel of an output. The 'edge' argument ++ says what edge of the output the surface will be anchored to. ++ After this request, the server will send a configure event with the ++ corresponding width/height that the client should use, and 0 for the ++ other dimension. E.g. if the edge is 'top', the width will be the ++ output's width, and the height will be 0. ++ ++ The surface must have a "desktop" surface role, as supported by ++ libweston-desktop. ++ ++ The compositor will take the panel's window geometry into account when ++ positioning other windows, so the panels are not covered. ++ ++ XXX: What happens if e.g. both top and left are used at the same time? ++ Who gets to have the corner? ++ ++ Only a single surface may be the panel for an output's edge. If a ++ surface already exists on an edge, a protocol error is raised. ++ </description> ++ <arg name="surface" type="object" interface="wl_surface"/> ++ <arg name="output" type="object" interface="wl_output"/> ++ <arg name="edge" type="uint" enum="edge"/> ++ </request> ++ ++ <request name="activate_app"> ++ <description summary="make client current window"> ++ Ask the compositor to make a toplevel to become the current/focused ++ window for window management purposes. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ ++ If multiple toplevels have the same app_id, the result is unspecified. ++ ++ XXX: Do we need feedback to say it didn't work? (e.g. client does ++ not exist) ++ </description> ++ <arg name="app_id" type="string"/> ++ <arg name="output" type="object" interface="wl_output"/> ++ </request> ++ ++ <event name="bound_ok" since="2"> ++ <description summary="event sent if binding was ok"> ++ Informs the client that it was able to bind the agl_shell ++ interface succesfully. Clients are required to wait for this ++ event before continuing further. ++ </description> ++ </event> ++ ++ <event name="bound_fail" since="2"> ++ <description summary="event sent if binding was nok"> ++ Informs the client that binding to the agl_shell interface was ++ unsuccesfull. Clients are required to wait for this event for ++ continuing further. ++ </description> ++ </event> ++ ++ <request name="destroy" type="destructor" since="2"> ++ <description summary="destroys the factory object"> ++ </description> ++ </request> ++ ++ <event name="app_state" since="3"> ++ <description summary="event sent when an application suffered state modification"> ++ Informs the client that an application has changed its state to another, ++ specified by the app_state enum. Client can use this event to track ++ current application state. For instance to know when the application has ++ started, or when terminated/stopped. ++ </description> ++ <arg name="app_id" type="string"/> ++ <arg name="state" type="uint" enum="app_state"/> ++ </event> ++ ++ ++ </interface> ++</protocol> +diff --git a/ui/ozone/platform/wayland/host/wayland_connection.cc b/ui/ozone/platform/wayland/host/wayland_connection.cc +index 6d44128e56458..93427c52e1284 100644 +--- a/ui/ozone/platform/wayland/host/wayland_connection.cc ++++ b/ui/ozone/platform/wayland/host/wayland_connection.cc +@@ -64,6 +64,8 @@ + #include "ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.h" + #include "ui/platform_window/common/platform_window_defaults.h" + ++#include "ui/ozone/platform/wayland/host/wayland_extensions.h" ++ + #if defined(USE_LIBWAYLAND_STUBS) + #include <dlfcn.h> + +@@ -238,6 +240,10 @@ bool WaylandConnection::Initialize() { + return false; + } + ++ if (!extensions_) { ++ extensions_ = CreateWaylandExtensions(this); ++ } ++ + // Now that the connection with the display server has been properly + // estabilished, initialize the event source and input objects. + DCHECK(!event_source_); +@@ -264,7 +270,7 @@ bool WaylandConnection::Initialize() { + LOG(ERROR) << "No wl_shm object"; + return false; + } +- if (!shell_v6_ && !shell_) { ++ if (!shell_v6_ && !shell_ && !(extensions_ && extensions_->HasShellObject())) { + LOG(ERROR) << "No Wayland shell found"; + return false; + } +@@ -434,7 +440,9 @@ void WaylandConnection::Global(void* data, + auto* connection = static_cast<WaylandConnection*>(data); + + auto factory_it = connection->global_object_factories_.find(interface); +- if (factory_it != connection->global_object_factories_.end()) { ++ if (connection->extensions_->Bind(registry, name, interface, version)) { ++ DVLOG(1) << "Successfully bound to " << interface; ++ } else if (factory_it != connection->global_object_factories_.end()) { + (*factory_it->second)(connection, registry, name, interface, version); + } else if (!connection->compositor_ && + strcmp(interface, "wl_compositor") == 0) { +diff --git a/ui/ozone/platform/wayland/host/wayland_connection.h b/ui/ozone/platform/wayland/host/wayland_connection.h +index d33959ad4066f..dfd1d060c73f2 100644 +--- a/ui/ozone/platform/wayland/host/wayland_connection.h ++++ b/ui/ozone/platform/wayland/host/wayland_connection.h +@@ -45,6 +45,7 @@ class WaylandBufferManagerHost; + class WaylandCursor; + class WaylandCursorBufferListener; + class WaylandEventSource; ++class WaylandExtensions; + class WaylandOutputManager; + class WaylandSeat; + class WaylandZAuraShell; +@@ -185,6 +186,8 @@ class WaylandConnection { + + WaylandZAuraShell* zaura_shell() const { return zaura_shell_.get(); } + ++ WaylandExtensions* extensions() { return extensions_.get(); } ++ + WaylandZcrColorManager* zcr_color_manager() const { + return zcr_color_manager_.get(); + } +@@ -424,6 +427,9 @@ class WaylandConnection { + std::unique_ptr<OverlayPrioritizer> overlay_prioritizer_; + std::unique_ptr<SurfaceAugmenter> surface_augmenter_; + ++ std::unique_ptr<WaylandExtensions> extensions_; ++ ++ + // Clipboard-related objects. |clipboard_| must be declared after all + // DeviceManager instances it depends on, otherwise tests may crash with + // UAFs while attempting to access already destroyed manager pointers. +diff --git a/ui/ozone/platform/wayland/host/wayland_extensions.h b/ui/ozone/platform/wayland/host/wayland_extensions.h +new file mode 100644 +index 0000000000000..3bd2fd7a211ae +--- /dev/null ++++ b/ui/ozone/platform/wayland/host/wayland_extensions.h +@@ -0,0 +1,56 @@ ++// Copyright 2019 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_EXTENSIONS_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_EXTENSIONS_H_ ++ ++#include <memory> ++ ++#include "ui/ozone/platform/wayland/common/wayland_object.h" ++ ++namespace ui { ++ ++class ShellToplevelWrapper; ++class ShellPopupWrapper; ++class WaylandConnection; ++ ++// Wayland extensions abstract interface to support extending of the Wayland ++// protocol. Inherit it to provide your own Wayland extensions implementation. ++class WaylandExtensions { ++ public: ++ WaylandExtensions() = default; ++ WaylandExtensions(const WaylandExtensions&) = delete; ++ WaylandExtensions& operator=(const WaylandExtensions&) = delete; ++ virtual ~WaylandExtensions() = default; ++ ++ // Binds to the extensions interface(s). Can encapsulate binding of several ++ // interfaces, defined by |interface|. ++ virtual bool Bind(wl_registry* registry, ++ uint32_t name, ++ const char* interface, ++ uint32_t version) = 0; ++ ++ // Checks whether the extensions have bound shell object(s). ++ virtual bool HasShellObject() const = 0; ++}; ++ ++// Creates Wayland extensions. ++std::unique_ptr<WaylandExtensions> CreateWaylandExtensions( ++ WaylandConnection* connection); ++ ++} // namespace ui ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_EXTENSIONS_H_ +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0006-Add-webos-agl-waylandwindow-window-tree-host-essenti.patch b/recipes-wam/cef/files/chromium/0006-Add-webos-agl-waylandwindow-window-tree-host-essenti.patch new file mode 100644 index 000000000..5ea8b83eb --- /dev/null +++ b/recipes-wam/cef/files/chromium/0006-Add-webos-agl-waylandwindow-window-tree-host-essenti.patch @@ -0,0 +1,1379 @@ +From a99977eb329ca0e114ad13ce31acc6ed38bb6a7b Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Wed, 17 May 2023 21:25:53 +0200 +Subject: [PATCH 6/9] Add webos/agl waylandwindow/window tree host essential + parts + +--- + ui/aura/BUILD.gn | 7 ++ + ui/aura/agl/window_tree_host_agl.h | 42 +++++++++ + ui/aura/agl/window_tree_host_platform_agl.cc | 50 +++++++++++ + ui/aura/agl/window_tree_host_platform_agl.h | 51 +++++++++++ + ui/aura/window_tree_host.h | 5 +- + ui/aura/window_tree_host_platform.cc | 4 +- + ui/aura/window_tree_host_platform.h | 4 +- + ui/ozone/platform/wayland/BUILD.gn | 1 - + .../platform/wayland/extensions/agl/BUILD.gn | 2 + + .../agl/host/wayland_extensions_agl.h | 10 ++- + .../agl/host/wayland_extensions_agl_impl.cc | 11 ++- + .../agl/host/wayland_extensions_agl_impl.h | 9 ++ + .../extensions/agl/host/wayland_window_agl.cc | 86 +++++++++++++++++++ + .../extensions/agl/host/wayland_window_agl.h | 49 +++++++++++ + .../wayland/gpu/gl_surface_wayland.cc | 10 ++- + .../host/gtk_primary_selection_device.cc | 2 +- + .../gtk_primary_selection_device_manager.cc | 4 +- + .../wayland/host/proxy/wayland_proxy_impl.cc | 2 +- + .../wayland/host/wayland_connection.cc | 23 ++++- + .../wayland/host/wayland_connection.h | 9 +- + .../platform/wayland/host/wayland_cursor.cc | 4 +- + .../wayland/host/wayland_data_device.cc | 10 +-- + .../wayland/host/wayland_data_device_base.cc | 2 +- + .../host/wayland_data_drag_controller.cc | 2 +- + .../wayland/host/wayland_data_source.cc | 6 +- + ui/ozone/platform/wayland/host/wayland_drm.cc | 6 +- + .../wayland/host/wayland_extensions.h | 6 ++ + .../platform/wayland/host/wayland_keyboard.cc | 4 +- + .../platform/wayland/host/wayland_popup.cc | 4 +- + ui/ozone/platform/wayland/host/wayland_shm.cc | 2 +- + .../platform/wayland/host/wayland_surface.cc | 2 +- + .../wayland/host/wayland_toplevel_window.cc | 14 +-- + .../platform/wayland/host/wayland_window.cc | 14 +-- + .../platform/wayland/host/wayland_window.h | 2 + + .../host/wayland_window_drag_controller.cc | 2 +- + .../wayland/host/wayland_window_factory.cc | 15 ++++ + .../wayland/host/wayland_zwp_linux_dmabuf.cc | 4 +- + .../wayland/host/xdg_foreign_wrapper.cc | 4 +- + .../wayland/host/xdg_popup_wrapper_impl.cc | 2 +- + .../wayland/host/xdg_surface_wrapper_impl.cc | 2 +- + .../host/zwp_primary_selection_device.cc | 2 +- + .../zwp_primary_selection_device_manager.cc | 4 +- + .../host/zxdg_surface_v6_wrapper_impl.cc | 2 +- + ui/platform_window/agl/platform_window_agl.h | 36 ++++++++ + ui/platform_window/platform_window.h | 4 +- + 45 files changed, 471 insertions(+), 65 deletions(-) + create mode 100644 ui/aura/agl/window_tree_host_agl.h + create mode 100644 ui/aura/agl/window_tree_host_platform_agl.cc + create mode 100644 ui/aura/agl/window_tree_host_platform_agl.h + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc + create mode 100644 ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h + create mode 100644 ui/platform_window/agl/platform_window_agl.h + +diff --git a/ui/aura/BUILD.gn b/ui/aura/BUILD.gn +index 1beb9003b2fad..f3d3e359a9704 100644 +--- a/ui/aura/BUILD.gn ++++ b/ui/aura/BUILD.gn +@@ -99,6 +99,13 @@ component("aura") { + "window_tree_host_platform.cc", + ] + ++ public += [ ++ "agl/window_tree_host_agl.h", ++ "agl/window_tree_host_platform_agl.h" ++ ] ++ ++ sources += [ "agl/window_tree_host_platform_agl.cc" ] ++ + friend = [ ":*" ] + + defines = [ "AURA_IMPLEMENTATION" ] +diff --git a/ui/aura/agl/window_tree_host_agl.h b/ui/aura/agl/window_tree_host_agl.h +new file mode 100644 +index 0000000000000..858a078d939d0 +--- /dev/null ++++ b/ui/aura/agl/window_tree_host_agl.h +@@ -0,0 +1,42 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_AURA_AGL_WINDOW_TREE_HOST_AGL_H_ ++#define UI_AURA_AGL_WINDOW_TREE_HOST_AGL_H_ ++ ++#include <string> ++ ++#include "ui/aura/aura_export.h" ++ ++namespace aura { ++ ++class AURA_EXPORT WindowTreeHostAgl { ++ public: ++ WindowTreeHostAgl() = default; ++ WindowTreeHostAgl(const WindowTreeHostAgl&) = delete; ++ WindowTreeHostAgl& operator=(const WindowTreeHostAgl&) = delete; ++ ~WindowTreeHostAgl() = default; ++ ++ virtual void SetAglActivateApp(const std::string& app) {} ++ virtual void SetAglAppId(const std::string& title) {} ++ virtual void SetAglReady() {} ++ virtual void SetAglBackground() {} ++ virtual void SetAglPanel(uint32_t edge) {} ++}; ++ ++} // namespace aura ++ ++#endif // UI_AURA_AGL_WINDOW_TREE_HOST_AGL_H_ +diff --git a/ui/aura/agl/window_tree_host_platform_agl.cc b/ui/aura/agl/window_tree_host_platform_agl.cc +new file mode 100644 +index 0000000000000..e34595fe0ed9c +--- /dev/null ++++ b/ui/aura/agl/window_tree_host_platform_agl.cc +@@ -0,0 +1,50 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#include "ui/aura/agl/window_tree_host_platform_agl.h" ++ ++#include "ui/aura/window_tree_host_platform.h" ++#include "ui/platform_window/platform_window.h" ++ ++namespace aura { ++ ++WindowTreeHostPlatformAgl::WindowTreeHostPlatformAgl( ++ std::unique_ptr<Window> window, ++ aura::WindowTreeHostPlatform* window_tree_host_platform) ++ : aura::WindowTreeHost(std::move(window)), ++ window_tree_host_platform_(window_tree_host_platform) {} ++ ++void WindowTreeHostPlatformAgl::SetAglActivateApp(const std::string& app) { ++ window_tree_host_platform_->platform_window()->SetAglActivateApp(app); ++} ++ ++void WindowTreeHostPlatformAgl::SetAglAppId(const std::string& title) { ++ window_tree_host_platform_->platform_window()->SetAglAppId(title); ++} ++ ++void WindowTreeHostPlatformAgl::SetAglReady() { ++ window_tree_host_platform_->platform_window()->SetAglReady(); ++} ++ ++void WindowTreeHostPlatformAgl::SetAglBackground() { ++ window_tree_host_platform_->platform_window()->SetAglBackground(); ++} ++ ++void WindowTreeHostPlatformAgl::SetAglPanel(uint32_t edge) { ++ window_tree_host_platform_->platform_window()->SetAglPanel(edge); ++} ++ ++} // namespace aura +diff --git a/ui/aura/agl/window_tree_host_platform_agl.h b/ui/aura/agl/window_tree_host_platform_agl.h +new file mode 100644 +index 0000000000000..181eefae346f7 +--- /dev/null ++++ b/ui/aura/agl/window_tree_host_platform_agl.h +@@ -0,0 +1,51 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_AURA_AGL_WINDOW_TREE_HOST_PLATFORM_AGL_H_ ++#define UI_AURA_AGL_WINDOW_TREE_HOST_PLATFORM_AGL_H_ ++ ++#include <memory> ++ ++#include "ui/aura/aura_export.h" ++#include "ui/aura/window_tree_host.h" ++ ++namespace aura { ++ ++class Window; ++class WindowTreeHostPlatform; ++ ++class AURA_EXPORT WindowTreeHostPlatformAgl : public aura::WindowTreeHost { ++ public: ++ explicit WindowTreeHostPlatformAgl( ++ std::unique_ptr<Window> window, ++ aura::WindowTreeHostPlatform* window_tree_host_platform); ++ WindowTreeHostPlatformAgl(const WindowTreeHostPlatformAgl&) = delete; ++ WindowTreeHostPlatformAgl& operator=(const WindowTreeHostPlatformAgl&) = delete; ++ ~WindowTreeHostPlatformAgl() override = default; ++ ++ void SetAglActivateApp(const std::string& app) override; ++ void SetAglAppId(const std::string& title) override; ++ void SetAglReady() override; ++ void SetAglBackground() override; ++ void SetAglPanel(uint32_t edge) override; ++ ++ private: ++ aura::WindowTreeHostPlatform* window_tree_host_platform_; ++}; ++ ++} // namespace aura ++ ++#endif // UI_AURA_AGL_WINDOW_TREE_HOST_PLATFORM_AGL_H_ +diff --git a/ui/aura/window_tree_host.h b/ui/aura/window_tree_host.h +index 0bdb86be66ba3..b7696e6373284 100644 +--- a/ui/aura/window_tree_host.h ++++ b/ui/aura/window_tree_host.h +@@ -30,6 +30,8 @@ + #include "ui/gfx/native_widget_types.h" + #include "ui/gfx/overlay_transform.h" + ++#include "ui/aura/agl/window_tree_host_agl.h" ++ + namespace gfx { + class Point; + class Rect; +@@ -66,7 +68,8 @@ class WindowTreeHostObserver; + class AURA_EXPORT WindowTreeHost : public ui::ImeKeyEventDispatcher, + public ui::EventSource, + public display::DisplayObserver, +- public ui::CompositorObserver { ++ public ui::CompositorObserver, ++ public WindowTreeHostAgl { + public: + // VideoCaptureLock ensures state necessary for capturing video remains in + // effect. For example, this may force keeping the compositor visible when +diff --git a/ui/aura/window_tree_host_platform.cc b/ui/aura/window_tree_host_platform.cc +index 4c31e785d7692..cecd1f4fc03fd 100644 +--- a/ui/aura/window_tree_host_platform.cc ++++ b/ui/aura/window_tree_host_platform.cc +@@ -51,7 +51,7 @@ std::unique_ptr<WindowTreeHost> WindowTreeHost::Create( + WindowTreeHostPlatform::WindowTreeHostPlatform( + ui::PlatformWindowInitProperties properties, + std::unique_ptr<Window> window) +- : WindowTreeHost(std::move(window)) { ++ : WindowTreeHostPlatformAgl(std::move(window), this) { + size_in_pixels_ = properties.bounds.size(); + CreateCompositor(false, false, properties.enable_compositing_based_throttling, + properties.compositor_memory_limit_mb); +@@ -59,7 +59,7 @@ WindowTreeHostPlatform::WindowTreeHostPlatform( + } + + WindowTreeHostPlatform::WindowTreeHostPlatform(std::unique_ptr<Window> window) +- : WindowTreeHost(std::move(window)), ++ : WindowTreeHostPlatformAgl(std::move(window), this), + widget_(gfx::kNullAcceleratedWidget), + current_cursor_(ui::mojom::CursorType::kNull) {} + +diff --git a/ui/aura/window_tree_host_platform.h b/ui/aura/window_tree_host_platform.h +index 3a9232743bda3..6c1e3a424afd4 100644 +--- a/ui/aura/window_tree_host_platform.h ++++ b/ui/aura/window_tree_host_platform.h +@@ -15,6 +15,8 @@ + #include "ui/gfx/native_widget_types.h" + #include "ui/platform_window/platform_window_delegate.h" + ++#include "ui/aura/agl/window_tree_host_platform_agl.h" ++ + namespace ui { + enum class DomCode; + class PlatformWindow; +@@ -26,7 +28,7 @@ namespace aura { + + // The unified WindowTreeHost implementation for platforms + // that implement PlatformWindow. +-class AURA_EXPORT WindowTreeHostPlatform : public WindowTreeHost, ++class AURA_EXPORT WindowTreeHostPlatform : public WindowTreeHostPlatformAgl, + public ui::PlatformWindowDelegate { + public: + explicit WindowTreeHostPlatform(ui::PlatformWindowInitProperties properties, +diff --git a/ui/ozone/platform/wayland/BUILD.gn b/ui/ozone/platform/wayland/BUILD.gn +index 1a2f889dc8947..86ff8269af9e0 100644 +--- a/ui/ozone/platform/wayland/BUILD.gn ++++ b/ui/ozone/platform/wayland/BUILD.gn +@@ -409,7 +409,6 @@ source_set("wayland") { + + sources += [ + "host/wayland_extensions.h", +- "host/wayland_extensions_stub.cc", + ] + + deps += [ "extensions/agl" ] +diff --git a/ui/ozone/platform/wayland/extensions/agl/BUILD.gn b/ui/ozone/platform/wayland/extensions/agl/BUILD.gn +index ce289bc5dbbca..01c590e53df58 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/BUILD.gn ++++ b/ui/ozone/platform/wayland/extensions/agl/BUILD.gn +@@ -31,6 +31,8 @@ source_set("agl") { + "host/wayland_extensions_agl.h", + "host/wayland_extensions_agl_impl.cc", + "host/wayland_extensions_agl_impl.h", ++ "host/wayland_window_agl.cc", ++ "host/wayland_window_agl.h", + ] + + deps = [ +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h +index df42fc00c84da..295154dfb437d 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h +@@ -20,6 +20,9 @@ + namespace ui { + + class AglShellWrapper; ++class PlatformWindowDelegate; ++class WaylandConnection; ++class WaylandWindow; + + // AGL extensions implementation for webOS/Lite + class WaylandExtensionsAgl { +@@ -29,9 +32,14 @@ class WaylandExtensionsAgl { + WaylandExtensionsAgl& operator=(const WaylandExtensionsAgl&) = delete; + virtual ~WaylandExtensionsAgl() = default; + ++ virtual std::unique_ptr<WaylandWindow> CreateWaylandWindow( ++ PlatformWindowDelegate* delegate, ++ WaylandConnection* connection) = 0; ++ ++ + virtual AglShellWrapper* GetAglShell() = 0; + }; + + } // namespace ui + +-#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_H_ +\ No newline at end of file ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_H_ +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +index 26a5f0550c302..87376cbb8a9d3 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +@@ -22,6 +22,7 @@ + #include "base/logging.h" + #include "ui/base/ui_base_switches.h" + #include "ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h" ++#include "ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h" + #include "ui/ozone/platform/wayland/extensions/agl/common/wayland_object_agl.h" + #include "ui/ozone/platform/wayland/host/wayland_connection.h" + +@@ -68,8 +69,8 @@ bool WaylandExtensionsAglImpl::Bind(wl_registry* registry, + agl_shell_ = + std::make_unique<AglShellWrapper>(aglshell.release(), connection_); + +- LOG(INFO) << "Waiting until bound..."; +- return agl_shell_->WaitUntilBoundOk(); ++ //LOG(INFO) << "Waiting until bound..."; ++ //return agl_shell_->WaitUntilBoundOk(); + } else { + LOG(INFO) << "Cant bind."; + } +@@ -85,6 +86,12 @@ AglShellWrapper* WaylandExtensionsAglImpl::GetAglShell() { + return agl_shell_.get(); + } + ++std::unique_ptr<WaylandWindow> WaylandExtensionsAglImpl::CreateWaylandWindow( ++ PlatformWindowDelegate* delegate, ++ WaylandConnection* connection) { ++ return std::make_unique<WaylandWindowAgl>(delegate, connection, this); ++} ++ + std::unique_ptr<WaylandExtensions> CreateWaylandExtensions( + WaylandConnection* connection) { + return std::make_unique<WaylandExtensionsAglImpl>(connection); +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h +index f6cbabe99ed0b..3218589f1a09a 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.h +@@ -17,12 +17,17 @@ + #ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_IMPL_H_ + #define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_EXTENSIONS_AGL_IMPL_H_ + ++#include <memory> ++ + #include "ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h" + #include "ui/ozone/platform/wayland/host/wayland_extensions.h" + + namespace ui { + + class AglShellWrapper; ++class PlatformWindowDelegate; ++class WaylandConnection; ++class WaylandWindow; + + // AGL extension implementation for webOS/Lite + class WaylandExtensionsAglImpl : public WaylandExtensions, +@@ -44,6 +49,10 @@ class WaylandExtensionsAglImpl : public WaylandExtensions, + // WaylandExtensionsAgl overrides + AglShellWrapper* GetAglShell() override; + ++ std::unique_ptr<WaylandWindow> CreateWaylandWindow( ++ PlatformWindowDelegate* delegate, ++ WaylandConnection* connection) override; ++ + private: + std::unique_ptr<AglShellWrapper> agl_shell_; + WaylandConnection* connection_; +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc +new file mode 100644 +index 0000000000000..97b21ae537658 +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc +@@ -0,0 +1,86 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#include "ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h" ++ ++#include "base/logging.h" ++#include "ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h" ++#include "ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl.h" ++#include "ui/ozone/platform/wayland/host/shell_surface_wrapper.h" ++#include "ui/ozone/platform/wayland/host/shell_toplevel_wrapper.h" ++#include "ui/ozone/platform/wayland/host/wayland_connection.h" ++ ++namespace ui { ++ ++WaylandWindowAgl::WaylandWindowAgl(PlatformWindowDelegate* delegate, ++ WaylandConnection* connection, ++ WaylandExtensionsAgl* agl_extensions) ++ : WaylandToplevelWindow(delegate, connection), ++ agl_extensions_(agl_extensions) {} ++ ++WaylandWindowAgl::~WaylandWindowAgl() = default; ++ ++void WaylandWindowAgl::SetAglActivateApp(const std::string& app) { ++ if (!agl_extensions_->GetAglShell()) { ++ LOG(ERROR) << "Agl shell wrapper is not created"; ++ return; ++ } ++ ++ agl_extensions_->GetAglShell()->SetAglActivateApp(app); ++ connection()->ScheduleFlush(); ++} ++ ++void WaylandWindowAgl::SetAglAppId(const std::string& title) { ++ if (!shell_toplevel()) { ++ LOG(ERROR) << "Shell toplevel is not created"; ++ return; ++ } ++ ++ shell_toplevel()->SetAppId(title); ++ connection()->ScheduleFlush(); ++} ++ ++void WaylandWindowAgl::SetAglReady() { ++ if (!agl_extensions_->GetAglShell()) { ++ LOG(ERROR) << "Agl shell wrapper is not created"; ++ return; ++ } ++ ++ agl_extensions_->GetAglShell()->SetAglReady(); ++ connection()->ScheduleFlush(); ++} ++ ++void WaylandWindowAgl::SetAglBackground() { ++ if (!agl_extensions_->GetAglShell()) { ++ LOG(ERROR) << "Agl shell wrapper is not created"; ++ return; ++ } ++ ++ agl_extensions_->GetAglShell()->SetAglBackground(this); ++ connection()->ScheduleFlush(); ++} ++ ++void WaylandWindowAgl::SetAglPanel(uint32_t edge) { ++ if (!agl_extensions_->GetAglShell()) { ++ LOG(ERROR) << "Agl shell wrapper is not created"; ++ return; ++ } ++ ++ agl_extensions_->GetAglShell()->SetAglPanel(this, edge); ++ connection()->ScheduleFlush(); ++} ++ ++} // namespace ui +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h +new file mode 100644 +index 0000000000000..b2a922604c001 +--- /dev/null ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h +@@ -0,0 +1,49 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++// ++ ++#ifndef UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_WINDOW_AGL_H_ ++#define UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_WINDOW_AGL_H_ ++ ++#include "ui/ozone/platform/wayland/host/wayland_toplevel_window.h" ++ ++namespace ui { ++ ++class WaylandExtensionsAgl; ++ ++class WaylandWindowAgl : public WaylandToplevelWindow { ++ public: ++ explicit WaylandWindowAgl(PlatformWindowDelegate* delegate, ++ WaylandConnection* connection, ++ WaylandExtensionsAgl* agl_extensions); ++ WaylandWindowAgl(const WaylandWindowAgl&) = delete; ++ WaylandWindowAgl& operator=(const WaylandWindowAgl&) = delete; ++ ~WaylandWindowAgl() override; ++ ++ // Overrides PlatformWindowAgl ++ void SetAglActivateApp(const std::string& app) override; ++ void SetAglAppId(const std::string& title) override; ++ void SetAglReady() override; ++ void SetAglBackground() override; ++ void SetAglPanel(uint32_t edge) override; ++ ++ private: ++ WaylandExtensionsAgl* agl_extensions_; ++}; ++ ++} // namespace ui ++ ++#endif // UI_OZONE_PLATFORM_WAYLAND_EXTENSIONS_AGL_HOST_WAYLAND_WINDOW_AGL_H_ +diff --git a/ui/ozone/platform/wayland/gpu/gl_surface_wayland.cc b/ui/ozone/platform/wayland/gpu/gl_surface_wayland.cc +index 1cef91bb39912..26ad374718005 100644 +--- a/ui/ozone/platform/wayland/gpu/gl_surface_wayland.cc ++++ b/ui/ozone/platform/wayland/gpu/gl_surface_wayland.cc +@@ -89,8 +89,14 @@ gfx::SwapResult GLSurfaceWayland::SwapBuffers(PresentationCallback callback, + return scoped_swap_buffers.result(); + } + window_->root_surface()->set_surface_buffer_scale(scale_factor_); +- return gl::NativeViewGLSurfaceEGL::SwapBuffers(std::move(callback), +- std::move(data)); ++ gfx::SwapResult result = gl::NativeViewGLSurfaceEGL::SwapBuffers(std::move(callback), ++ std::move(data)); ++ ++ if (window_) { ++ window_->OnSurfaceContentChanged(); ++ } ++ ++ return result; + } + + gfx::SwapResult GLSurfaceWayland::PostSubBuffer(int x, +diff --git a/ui/ozone/platform/wayland/host/gtk_primary_selection_device.cc b/ui/ozone/platform/wayland/host/gtk_primary_selection_device.cc +index 43445ea2442b4..94f0739599142 100644 +--- a/ui/ozone/platform/wayland/host/gtk_primary_selection_device.cc ++++ b/ui/ozone/platform/wayland/host/gtk_primary_selection_device.cc +@@ -31,7 +31,7 @@ void GtkPrimarySelectionDevice::SetSelectionSource( + auto* data_source = source ? source->data_source() : nullptr; + gtk_primary_selection_device_set_selection(data_device_.get(), data_source, + serial); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + // static +diff --git a/ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.cc b/ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.cc +index 2c39409808128..1e07ae6009776 100644 +--- a/ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.cc ++++ b/ui/ozone/platform/wayland/host/gtk_primary_selection_device_manager.cc +@@ -66,7 +66,7 @@ GtkPrimarySelectionDevice* GtkPrimarySelectionDeviceManager::GetDevice() { + connection_, + gtk_primary_selection_device_manager_get_device( + device_manager_.get(), connection_->seat()->wl_object())); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + DCHECK(device_); + return device_.get(); +@@ -77,7 +77,7 @@ GtkPrimarySelectionDeviceManager::CreateSource( + GtkPrimarySelectionSource::Delegate* delegate) { + auto* data_source = + gtk_primary_selection_device_manager_create_source(device_manager_.get()); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return std::make_unique<GtkPrimarySelectionSource>(data_source, connection_, + delegate); + } +diff --git a/ui/ozone/platform/wayland/host/proxy/wayland_proxy_impl.cc b/ui/ozone/platform/wayland/host/proxy/wayland_proxy_impl.cc +index dee90b1aaaf72..caad70e0ab1cb 100644 +--- a/ui/ozone/platform/wayland/host/proxy/wayland_proxy_impl.cc ++++ b/ui/ozone/platform/wayland/host/proxy/wayland_proxy_impl.cc +@@ -75,7 +75,7 @@ void WaylandProxyImpl::DestroyShmForWlBuffer(wl_buffer* buffer) { + } + + void WaylandProxyImpl::FlushForTesting() { +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + ui::PlatformWindowType WaylandProxyImpl::GetWindowType( +diff --git a/ui/ozone/platform/wayland/host/wayland_connection.cc b/ui/ozone/platform/wayland/host/wayland_connection.cc +index 93427c52e1284..e2d45a6f5dc67 100644 +--- a/ui/ozone/platform/wayland/host/wayland_connection.cc ++++ b/ui/ozone/platform/wayland/host/wayland_connection.cc +@@ -285,6 +285,20 @@ bool WaylandConnection::Initialize() { + return true; + } + ++void WaylandConnection::ScheduleFlush() { ++ // When we are in tests, the message loop is set later when the ++ // initialization of the OzonePlatform complete. Thus, just ++ // flush directly. This doesn't happen in normal run. ++ if (!base::CurrentUIThread::IsSet()) { ++ Flush(); ++ } else if (!scheduled_flush_) { ++ base::ThreadTaskRunnerHandle::Get()->PostTask( ++ FROM_HERE, ++ base::BindOnce(&WaylandConnection::Flush, base::Unretained(this))); ++ scheduled_flush_ = true; ++ } ++} ++ + void WaylandConnection::RoundTripQueue() { + if (roundtrip_closure_for_testing_) { + roundtrip_closure_for_testing_.Run(); +@@ -354,6 +368,7 @@ void WaylandConnection::RegisterGlobalObjectFactory( + + void WaylandConnection::Flush() { + wl_display_flush(display_.get()); ++ scheduled_flush_ = false; + } + + void WaylandConnection::UpdateInputDevices() { +@@ -441,7 +456,7 @@ void WaylandConnection::Global(void* data, + + auto factory_it = connection->global_object_factories_.find(interface); + if (connection->extensions_->Bind(registry, name, interface, version)) { +- DVLOG(1) << "Successfully bound to " << interface; ++ LOG(INFO) << "Successfully bound to " << interface; + } else if (factory_it != connection->global_object_factories_.end()) { + (*factory_it->second)(connection, registry, name, interface, version); + } else if (!connection->compositor_ && +@@ -609,7 +624,7 @@ void WaylandConnection::Global(void* data, + + connection->available_globals_.emplace_back(interface, version); + +- connection->Flush(); ++ connection->ScheduleFlush(); + } + + base::TimeTicks WaylandConnection::ConvertPresentationTime(uint32_t tv_sec_hi, +@@ -674,14 +689,14 @@ void WaylandConnection::PingV6(void* data, + uint32_t serial) { + WaylandConnection* connection = static_cast<WaylandConnection*>(data); + zxdg_shell_v6_pong(shell_v6, serial); +- connection->Flush(); ++ connection->ScheduleFlush(); + } + + // static + void WaylandConnection::Ping(void* data, xdg_wm_base* shell, uint32_t serial) { + WaylandConnection* connection = static_cast<WaylandConnection*>(data); + xdg_wm_base_pong(shell, serial); +- connection->Flush(); ++ connection->ScheduleFlush(); + } + + // static +diff --git a/ui/ozone/platform/wayland/host/wayland_connection.h b/ui/ozone/platform/wayland/host/wayland_connection.h +index dfd1d060c73f2..d2d7a866d3af8 100644 +--- a/ui/ozone/platform/wayland/host/wayland_connection.h ++++ b/ui/ozone/platform/wayland/host/wayland_connection.h +@@ -94,8 +94,8 @@ class WaylandConnection { + + bool Initialize(); + +- // Immediately flushes the Wayland display. +- void Flush(); ++ // Schedules a flush of the Wayland connection. ++ void ScheduleFlush(); + + // Calls wl_display_roundtrip_queue. Might be required during initialization + // of some objects that should block until they are initialized. +@@ -340,6 +340,9 @@ class WaylandConnection { + friend class ZwpIdleInhibitManager; + friend class ZwpPrimarySelectionDeviceManager; + ++ // Immediately flushes the Wayland display. ++ void Flush(); ++ + void RegisterGlobalObjectFactory(const char* interface_name, + wl::GlobalObjectFactory factory); + +@@ -467,6 +470,8 @@ class WaylandConnection { + // sizes. + bool surface_submission_in_pixel_coordinates_ = false; + ++ bool scheduled_flush_ = false; ++ + wl::SerialTracker serial_tracker_; + + // Global Wayland interfaces available in the current session, with their +diff --git a/ui/ozone/platform/wayland/host/wayland_cursor.cc b/ui/ozone/platform/wayland/host/wayland_cursor.cc +index 891ca2e5e1f3c..48ac8b8925ddd 100644 +--- a/ui/ozone/platform/wayland/host/wayland_cursor.cc ++++ b/ui/ozone/platform/wayland/host/wayland_cursor.cc +@@ -109,7 +109,7 @@ void WaylandCursor::HideCursor() { + wl_surface_attach(pointer_surface_.get(), nullptr, 0, 0); + wl_surface_commit(pointer_surface_.get()); + +- connection_->Flush(); ++ connection_->ScheduleFlush(); + + if (listener_) + listener_->OnCursorBufferAttached(nullptr); +@@ -160,7 +160,7 @@ void WaylandCursor::AttachAndCommit(wl_buffer* buffer, + wl_surface_attach(pointer_surface_.get(), buffer, 0, 0); + wl_surface_commit(pointer_surface_.get()); + +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + } // namespace ui +diff --git a/ui/ozone/platform/wayland/host/wayland_data_device.cc b/ui/ozone/platform/wayland/host/wayland_data_device.cc +index a1d691b6315ac..ccc7bfb0305a8 100644 +--- a/ui/ozone/platform/wayland/host/wayland_data_device.cc ++++ b/ui/ozone/platform/wayland/host/wayland_data_device.cc +@@ -46,7 +46,7 @@ void WaylandDataDevice::StartDrag(const WaylandDataSource& data_source, + origin_window.root_surface()->surface(), + icon_surface, serial); + drag_delegate_->DrawIcon(); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandDataDevice::ResetDragDelegate() { +@@ -78,7 +78,7 @@ void WaylandDataDevice::SetSelectionSource(WaylandDataSource* source, + uint32_t serial) { + auto* data_source = source ? source->data_source() : nullptr; + wl_data_device_set_selection(data_device_.get(), data_source, serial); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandDataDevice::ReadDragDataFromFD(base::ScopedFD fd, +@@ -140,7 +140,7 @@ void WaylandDataDevice::OnEnter(void* data, + gfx::PointF(wl_fixed_to_double(x), wl_fixed_to_double(y)), window); + self->drag_delegate_->OnDragEnter(window, point, serial); + +- self->connection()->Flush(); ++ self->connection()->ScheduleFlush(); + } + + void WaylandDataDevice::OnMotion(void* data, +@@ -161,7 +161,7 @@ void WaylandDataDevice::OnDrop(void* data, wl_data_device* data_device) { + auto* self = static_cast<WaylandDataDevice*>(data); + if (self->drag_delegate_) { + self->drag_delegate_->OnDragDrop(); +- self->connection()->Flush(); ++ self->connection()->ScheduleFlush(); + } + + // There are buggy Exo versions, which send 'drop' event (even for +@@ -178,7 +178,7 @@ void WaylandDataDevice::OnLeave(void* data, wl_data_device* data_device) { + auto* self = static_cast<WaylandDataDevice*>(data); + if (self->drag_delegate_) { + self->drag_delegate_->OnDragLeave(); +- self->connection()->Flush(); ++ self->connection()->ScheduleFlush(); + } + self->ResetDragDelegateIfNeeded(); + } +diff --git a/ui/ozone/platform/wayland/host/wayland_data_device_base.cc b/ui/ozone/platform/wayland/host/wayland_data_device_base.cc +index 4287f72617708..d0c077c2e69ea 100644 +--- a/ui/ozone/platform/wayland/host/wayland_data_device_base.cc ++++ b/ui/ozone/platform/wayland/host/wayland_data_device_base.cc +@@ -72,7 +72,7 @@ void WaylandDataDeviceBase::RegisterDeferredReadCallback() { + + wl_callback_add_listener(deferred_read_callback_.get(), &kListener, this); + +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + void WaylandDataDeviceBase::RegisterDeferredReadClosure( +diff --git a/ui/ozone/platform/wayland/host/wayland_data_drag_controller.cc b/ui/ozone/platform/wayland/host/wayland_data_drag_controller.cc +index f2123ec8bac3f..11750a3f55da2 100644 +--- a/ui/ozone/platform/wayland/host/wayland_data_drag_controller.cc ++++ b/ui/ozone/platform/wayland/host/wayland_data_drag_controller.cc +@@ -217,7 +217,7 @@ void WaylandDataDragController::OnDragSurfaceFrame(void* data, + DCHECK(self); + self->DrawIconInternal(); + self->icon_frame_callback_.reset(); +- self->connection_->Flush(); ++ self->connection_->ScheduleFlush(); + } + + void WaylandDataDragController::DrawIconInternal() { +diff --git a/ui/ozone/platform/wayland/host/wayland_data_source.cc b/ui/ozone/platform/wayland/host/wayland_data_source.cc +index de1e110f73b11..e24f31b1a8f52 100644 +--- a/ui/ozone/platform/wayland/host/wayland_data_source.cc ++++ b/ui/ozone/platform/wayland/host/wayland_data_source.cc +@@ -119,7 +119,7 @@ void DataSource<wl_data_source>::Offer( + const std::vector<std::string>& mime_types) { + for (auto& mime_type : mime_types) + wl_data_source_offer(data_source_.get(), mime_type.c_str()); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + template <typename T> +@@ -154,7 +154,7 @@ void DataSource<gtk_primary_selection_source>::Offer( + const std::vector<std::string>& mime_types) { + for (const auto& mime_type : mime_types) + gtk_primary_selection_source_offer(data_source_.get(), mime_type.c_str()); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + template <> +@@ -173,7 +173,7 @@ void DataSource<zwp_primary_selection_source_v1>::Offer( + for (const auto& mime_type : mime_types) + zwp_primary_selection_source_v1_offer(data_source_.get(), + mime_type.c_str()); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + template class DataSource<gtk_primary_selection_source>; +diff --git a/ui/ozone/platform/wayland/host/wayland_drm.cc b/ui/ozone/platform/wayland/host/wayland_drm.cc +index 7edc0da798b9b..280350d9286c0 100644 +--- a/ui/ozone/platform/wayland/host/wayland_drm.cc ++++ b/ui/ozone/platform/wayland/host/wayland_drm.cc +@@ -57,7 +57,7 @@ WaylandDrm::WaylandDrm(wl_drm* drm, WaylandConnection* connection) + &Capabilities, + }; + wl_drm_add_listener(wl_drm_.get(), &kDrmListener, this); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + + // A roundtrip after binding guarantees that the client has received all + // supported formats and capabilities of the device. +@@ -91,7 +91,7 @@ void WaylandDrm::CreateBuffer(const base::ScopedFD& fd, + wl::Object<wl_buffer> buffer(wl_drm_create_prime_buffer( + wl_drm_.get(), fd.get(), size.width(), size.height(), format, offset[0], + stride[0], offset[1], stride[1], offset[2], stride[2])); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + + std::move(callback).Run(std::move(buffer)); + } +@@ -145,7 +145,7 @@ void WaylandDrm::Authenticate(const char* drm_device_path) { + } + + wl_drm_authenticate(wl_drm_.get(), magic); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + + // Do the roundtrip to make sure the server processes this request and + // authenticates us. +diff --git a/ui/ozone/platform/wayland/host/wayland_extensions.h b/ui/ozone/platform/wayland/host/wayland_extensions.h +index 3bd2fd7a211ae..f6ed47507d217 100644 +--- a/ui/ozone/platform/wayland/host/wayland_extensions.h ++++ b/ui/ozone/platform/wayland/host/wayland_extensions.h +@@ -25,7 +25,9 @@ namespace ui { + + class ShellToplevelWrapper; + class ShellPopupWrapper; ++class PlatformWindowDelegate; + class WaylandConnection; ++class WaylandWindow; + + // Wayland extensions abstract interface to support extending of the Wayland + // protocol. Inherit it to provide your own Wayland extensions implementation. +@@ -45,6 +47,10 @@ class WaylandExtensions { + + // Checks whether the extensions have bound shell object(s). + virtual bool HasShellObject() const = 0; ++ ++ virtual std::unique_ptr<WaylandWindow> CreateWaylandWindow( ++ PlatformWindowDelegate* delegate, ++ WaylandConnection* connection) = 0; + }; + + // Creates Wayland extensions. +diff --git a/ui/ozone/platform/wayland/host/wayland_keyboard.cc b/ui/ozone/platform/wayland/host/wayland_keyboard.cc +index c6e64f1e55da3..473a702bf8987 100644 +--- a/ui/ozone/platform/wayland/host/wayland_keyboard.cc ++++ b/ui/ozone/platform/wayland/host/wayland_keyboard.cc +@@ -54,7 +54,7 @@ class WaylandKeyboard::ZCRExtendedKeyboard { + + void AckKey(uint32_t serial, bool handled) { + zcr_extended_keyboard_v1_ack_key(obj_.get(), serial, handled); +- keyboard_->connection_->Flush(); ++ keyboard_->connection_->ScheduleFlush(); + } + + // Returns true if connected object will send zcr_extended_keyboard::peek_key. +@@ -247,7 +247,7 @@ void WaylandKeyboard::FlushInput(base::OnceClosure closure) { + // get spurious repeats. + sync_callback_.reset(wl_display_sync(connection_->display_wrapper())); + wl_callback_add_listener(sync_callback_.get(), &callback_listener_, this); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + void WaylandKeyboard::DispatchKey(unsigned int key, +diff --git a/ui/ozone/platform/wayland/host/wayland_popup.cc b/ui/ozone/platform/wayland/host/wayland_popup.cc +index 84e429457462e..cb13557093dc2 100644 +--- a/ui/ozone/platform/wayland/host/wayland_popup.cc ++++ b/ui/ozone/platform/wayland/host/wayland_popup.cc +@@ -124,7 +124,7 @@ void WaylandPopup::Show(bool inactive) { + return; + } + +- connection()->Flush(); ++ connection()->ScheduleFlush(); + WaylandWindow::Show(inactive); + } + +@@ -147,7 +147,7 @@ void WaylandPopup::Hide() { + decorated_via_aura_popup_ = false; + } + +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + bool WaylandPopup::IsVisible() const { +diff --git a/ui/ozone/platform/wayland/host/wayland_shm.cc b/ui/ozone/platform/wayland/host/wayland_shm.cc +index 80d27227b9ab3..2b6c4f31ca0d8 100644 +--- a/ui/ozone/platform/wayland/host/wayland_shm.cc ++++ b/ui/ozone/platform/wayland/host/wayland_shm.cc +@@ -62,7 +62,7 @@ wl::Object<wl_buffer> WaylandShm::CreateBuffer(const base::ScopedFD& fd, + with_alpha_channel ? WL_SHM_FORMAT_ARGB8888 : WL_SHM_FORMAT_XRGB8888; + wl::Object<wl_buffer> shm_buffer(wl_shm_pool_create_buffer( + pool.get(), 0, size.width(), size.height(), size.width() * 4, format)); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return shm_buffer; + } + +diff --git a/ui/ozone/platform/wayland/host/wayland_surface.cc b/ui/ozone/platform/wayland/host/wayland_surface.cc +index cd178f9aaee00..ffe5062402b33 100644 +--- a/ui/ozone/platform/wayland/host/wayland_surface.cc ++++ b/ui/ozone/platform/wayland/host/wayland_surface.cc +@@ -267,7 +267,7 @@ void WaylandSurface::UpdateBufferDamageRegion(const gfx::Rect& damage_px) { + void WaylandSurface::Commit(bool flush) { + wl_surface_commit(surface_.get()); + if (flush) +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + void WaylandSurface::set_surface_buffer_scale(float scale) { +diff --git a/ui/ozone/platform/wayland/host/wayland_toplevel_window.cc b/ui/ozone/platform/wayland/host/wayland_toplevel_window.cc +index e39daa898c9a5..68aebd357fdc2 100644 +--- a/ui/ozone/platform/wayland/host/wayland_toplevel_window.cc ++++ b/ui/ozone/platform/wayland/host/wayland_toplevel_window.cc +@@ -131,7 +131,7 @@ void WaylandToplevelWindow::DispatchHostWindowDragMovement( + else + shell_toplevel_->SurfaceResize(connection(), hittest); + +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandToplevelWindow::Show(bool inactive) { +@@ -166,7 +166,7 @@ void WaylandToplevelWindow::Hide() { + aura_surface_.reset(); + } + shell_toplevel_.reset(); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + bool WaylandToplevelWindow::IsVisible() const { +@@ -183,7 +183,7 @@ void WaylandToplevelWindow::SetTitle(const std::u16string& title) { + + if (shell_toplevel_) { + shell_toplevel_->SetTitle(title); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + } + +@@ -262,13 +262,13 @@ void WaylandToplevelWindow::Activate() { + // but nothing more happens (until the user moves the mouse over a Lacros + // window in which case events will start and the activation will come + // through). +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandToplevelWindow::Deactivate() { + if (shell_toplevel_ && shell_toplevel_->SupportsActivation()) { + shell_toplevel_->Deactivate(); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + } + +@@ -877,7 +877,7 @@ void WaylandToplevelWindow::TriggerStateChanges() { + + delegate()->OnWindowStateChanged(previous_state_, state_); + +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandToplevelWindow::SetWindowState(PlatformWindowState state) { +@@ -908,7 +908,7 @@ void WaylandToplevelWindow::SetSizeConstraints() { + if (max_size_dip.has_value()) + shell_toplevel_->SetMaxSize(max_size_dip->width(), max_size_dip->height()); + +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + void WaylandToplevelWindow::SetOrResetRestoredBounds() { +diff --git a/ui/ozone/platform/wayland/host/wayland_window.cc b/ui/ozone/platform/wayland/host/wayland_window.cc +index f8b8c36a745e5..e415efde8ccd8 100644 +--- a/ui/ozone/platform/wayland/host/wayland_window.cc ++++ b/ui/ozone/platform/wayland/host/wayland_window.cc +@@ -430,7 +430,7 @@ void WaylandWindow::SetDecorationInsets(const gfx::Insets* insets_px) { + else + frame_insets_px_ = absl::nullopt; + UpdateDecorations(); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + void WaylandWindow::SetWindowIcons(const gfx::ImageSkia& window_icon, +@@ -522,6 +522,10 @@ void WaylandWindow::HandleSurfaceConfigure(uint32_t serial) { + << "Only shell surfaces must receive HandleSurfaceConfigure calls."; + } + ++void WaylandWindow::OnSurfaceContentChanged() { ++ connection_->ScheduleFlush(); ++} ++ + void WaylandWindow::HandleToplevelConfigure(int32_t widht, + int32_t height, + const WindowStates& window_states) { +@@ -551,7 +555,7 @@ void WaylandWindow::UpdateVisualSize(const gfx::Size& size_px) { + + if (apply_pending_state_on_update_visual_size_for_testing_) { + root_surface_->ApplyPendingState(); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + } + +@@ -661,7 +665,7 @@ bool WaylandWindow::Initialize(PlatformWindowInitProperties properties) { + std::vector<gfx::Rect> region{gfx::Rect{size_px_}}; + root_surface_->set_opaque_region(®ion); + root_surface_->ApplyPendingState(); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + + return true; + } +@@ -957,7 +961,7 @@ void WaylandWindow::ProcessPendingBoundsDip(uint32_t serial) { + // window has been applied. + SetWindowGeometry(pending_bounds_dip_); + AckConfigure(serial); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } else if (!pending_configures_.empty() && + pending_bounds_dip_.size() == + pending_configures_.back().bounds_dip.size()) { +@@ -1051,7 +1055,7 @@ bool WaylandWindow::ProcessVisualSizeUpdate(const gfx::Size& size_px) { + auto serial = result->serial; + SetWindowGeometry(result->bounds_dip); + AckConfigure(serial); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + pending_configures_.erase(pending_configures_.begin(), ++result); + return true; + } +diff --git a/ui/ozone/platform/wayland/host/wayland_window.h b/ui/ozone/platform/wayland/host/wayland_window.h +index f0f75d4481cd2..dae1ddcd2933f 100644 +--- a/ui/ozone/platform/wayland/host/wayland_window.h ++++ b/ui/ozone/platform/wayland/host/wayland_window.h +@@ -218,6 +218,8 @@ class WaylandWindow : public PlatformWindow, + // currently bound to. + virtual void HandleSurfaceConfigure(uint32_t serial); + ++ void OnSurfaceContentChanged(); ++ + struct WindowStates { + bool is_maximized = false; + bool is_fullscreen = false; +diff --git a/ui/ozone/platform/wayland/host/wayland_window_drag_controller.cc b/ui/ozone/platform/wayland/host/wayland_window_drag_controller.cc +index 6f45f47a71c25..a269ec9b368a4 100644 +--- a/ui/ozone/platform/wayland/host/wayland_window_drag_controller.cc ++++ b/ui/ozone/platform/wayland/host/wayland_window_drag_controller.cc +@@ -84,7 +84,7 @@ class WaylandWindowDragController::ExtendedDragSource { + auto* surface = window ? window->root_surface()->surface() : nullptr; + zcr_extended_drag_source_v1_drag(source_.get(), surface, offset.x(), + offset.y()); +- connection_.Flush(); ++ connection_.ScheduleFlush(); + } + + private: +diff --git a/ui/ozone/platform/wayland/host/wayland_window_factory.cc b/ui/ozone/platform/wayland/host/wayland_window_factory.cc +index 4857125bb5f34..b2f73218681b9 100644 +--- a/ui/ozone/platform/wayland/host/wayland_window_factory.cc ++++ b/ui/ozone/platform/wayland/host/wayland_window_factory.cc +@@ -13,6 +13,8 @@ + #include "ui/ozone/platform/wayland/host/wayland_window.h" + #include "ui/platform_window/platform_window_init_properties.h" + ++#include "ui/ozone/platform/wayland/host/wayland_extensions.h" ++ + namespace ui { + + namespace { +@@ -41,6 +43,13 @@ std::unique_ptr<WaylandWindow> WaylandWindow::Create( + // toplevel window instead. + if (auto* parent = + GetParentWindow(connection, properties.parent_widget)) { ++ ++ if (connection->extensions()) { ++ window = connection->extensions()->CreateWaylandWindow(delegate, ++ connection); ++ if (window) ++ break; ++ } + window = std::make_unique<WaylandPopup>(delegate, connection, parent); + } else { + DLOG(WARNING) << "Failed to determine for menu/popup window."; +@@ -52,6 +61,12 @@ std::unique_ptr<WaylandWindow> WaylandWindow::Create( + case PlatformWindowType::kDrag: + // TODO(msisov): Figure out what kind of surface we need to create for + // bubble and drag windows. ++ if (connection->extensions()) { ++ window = ++ connection->extensions()->CreateWaylandWindow(delegate, connection); ++ if (window) ++ break; ++ } + window = std::make_unique<WaylandToplevelWindow>(delegate, connection); + break; + default: +diff --git a/ui/ozone/platform/wayland/host/wayland_zwp_linux_dmabuf.cc b/ui/ozone/platform/wayland/host/wayland_zwp_linux_dmabuf.cc +index 3db8cb5e5dba9..5d6293e016842 100644 +--- a/ui/ozone/platform/wayland/host/wayland_zwp_linux_dmabuf.cc ++++ b/ui/ozone/platform/wayland/host/wayland_zwp_linux_dmabuf.cc +@@ -104,7 +104,7 @@ void WaylandZwpLinuxDmabuf::CreateBuffer(const base::ScopedFD& fd, + // created buffer and notify the client about it via the |callback|. + pending_params_.emplace(std::move(params), std::move(callback)); + } +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + bool WaylandZwpLinuxDmabuf::CanCreateBufferImmed() const { +@@ -150,7 +150,7 @@ void WaylandZwpLinuxDmabuf::NotifyRequestCreateBufferDone( + + pending_params_.erase(it); + +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + // static +diff --git a/ui/ozone/platform/wayland/host/xdg_foreign_wrapper.cc b/ui/ozone/platform/wayland/host/xdg_foreign_wrapper.cc +index 8b8591fabe015..9b3c6e5136d5d 100644 +--- a/ui/ozone/platform/wayland/host/xdg_foreign_wrapper.cc ++++ b/ui/ozone/platform/wayland/host/xdg_foreign_wrapper.cc +@@ -162,7 +162,7 @@ void XdgForeignWrapperImpl<zxdg_exporter_v1, zxdg_exported_v1>:: + zxdg_exported_v1_add_listener(exported_surface.exported.get(), + &kExportedListener, this); + exported_surfaces_.emplace_back(std::move(exported_surface)); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + template <> +@@ -176,7 +176,7 @@ void XdgForeignWrapperImpl<zxdg_exporter_v2, zxdg_exported_v2>:: + zxdg_exported_v2_add_listener(exported_surface.exported.get(), + &kExportedListener, this); + exported_surfaces_.emplace_back(std::move(exported_surface)); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + + // static +diff --git a/ui/ozone/platform/wayland/host/xdg_popup_wrapper_impl.cc b/ui/ozone/platform/wayland/host/xdg_popup_wrapper_impl.cc +index 23b7ad8fbf3cc..2e1f8fc129bf7 100644 +--- a/ui/ozone/platform/wayland/host/xdg_popup_wrapper_impl.cc ++++ b/ui/ozone/platform/wayland/host/xdg_popup_wrapper_impl.cc +@@ -230,7 +230,7 @@ bool XDGPopupWrapperImpl::SetBounds(const gfx::Rect& new_bounds) { + xdg_popup_reposition(xdg_popup_.get(), positioner.get(), + ++next_reposition_token_); + +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return true; + } + +diff --git a/ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.cc b/ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.cc +index 048071b4b7b76..692f562e203f0 100644 +--- a/ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.cc ++++ b/ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.cc +@@ -40,7 +40,7 @@ bool XDGSurfaceWrapperImpl::Initialize() { + } + + xdg_surface_add_listener(xdg_surface_.get(), &xdg_surface_listener, this); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return true; + } + +diff --git a/ui/ozone/platform/wayland/host/zwp_primary_selection_device.cc b/ui/ozone/platform/wayland/host/zwp_primary_selection_device.cc +index d02c76db80aa2..9e7e0a916d66d 100644 +--- a/ui/ozone/platform/wayland/host/zwp_primary_selection_device.cc ++++ b/ui/ozone/platform/wayland/host/zwp_primary_selection_device.cc +@@ -31,7 +31,7 @@ void ZwpPrimarySelectionDevice::SetSelectionSource( + auto* data_source = source ? source->data_source() : nullptr; + zwp_primary_selection_device_v1_set_selection(data_device_.get(), data_source, + serial); +- connection()->Flush(); ++ connection()->ScheduleFlush(); + } + + // static +diff --git a/ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.cc b/ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.cc +index 9d5d79635b66d..2ca82ce6031ba 100644 +--- a/ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.cc ++++ b/ui/ozone/platform/wayland/host/zwp_primary_selection_device_manager.cc +@@ -66,7 +66,7 @@ ZwpPrimarySelectionDevice* ZwpPrimarySelectionDeviceManager::GetDevice() { + connection_, + zwp_primary_selection_device_manager_v1_get_device( + device_manager_.get(), connection_->seat()->wl_object())); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + } + DCHECK(device_); + return device_.get(); +@@ -77,7 +77,7 @@ ZwpPrimarySelectionDeviceManager::CreateSource( + ZwpPrimarySelectionSource::Delegate* delegate) { + auto* data_source = zwp_primary_selection_device_manager_v1_create_source( + device_manager_.get()); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return std::make_unique<ZwpPrimarySelectionSource>(data_source, connection_, + delegate); + } +diff --git a/ui/ozone/platform/wayland/host/zxdg_surface_v6_wrapper_impl.cc b/ui/ozone/platform/wayland/host/zxdg_surface_v6_wrapper_impl.cc +index e900f9d37e8ad..5c4c538800f65 100644 +--- a/ui/ozone/platform/wayland/host/zxdg_surface_v6_wrapper_impl.cc ++++ b/ui/ozone/platform/wayland/host/zxdg_surface_v6_wrapper_impl.cc +@@ -43,7 +43,7 @@ bool ZXDGSurfaceV6WrapperImpl::Initialize() { + + zxdg_surface_v6_add_listener(zxdg_surface_v6_.get(), + &zxdg_surface_v6_listener, this); +- connection_->Flush(); ++ connection_->ScheduleFlush(); + return true; + } + +diff --git a/ui/platform_window/agl/platform_window_agl.h b/ui/platform_window/agl/platform_window_agl.h +new file mode 100644 +index 0000000000000..4bc915d663e72 +--- /dev/null ++++ b/ui/platform_window/agl/platform_window_agl.h +@@ -0,0 +1,36 @@ ++// Copyright 2021 LG Electronics, Inc. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// SPDX-License-Identifier: Apache-2.0 ++ ++#ifndef UI_PLATFORM_WINDOW_AGL_PLATFORM_WINDOW_AGL_H_ ++#define UI_PLATFORM_WINDOW_AGL_PLATFORM_WINDOW_AGL_H_ ++ ++#include <string> ++ ++namespace ui { ++ ++// AGL additions for platform window. ++class PlatformWindowAgl { ++ public: ++ virtual void SetAglActivateApp(const std::string& app) {} ++ virtual void SetAglAppId(const std::string& title) {} ++ virtual void SetAglReady() {} ++ virtual void SetAglBackground() {} ++ virtual void SetAglPanel(uint32_t edge) {} ++}; ++ ++} // namespace ui ++ ++#endif // UI_PLATFORM_WINDOW_AGL_PLATFORM_WINDOW_AGL_H_ +diff --git a/ui/platform_window/platform_window.h b/ui/platform_window/platform_window.h +index a7bd3ef17a728..80f67671b88cf 100644 +--- a/ui/platform_window/platform_window.h ++++ b/ui/platform_window/platform_window.h +@@ -9,6 +9,7 @@ + #include <string> + #include <vector> + ++#include "agl/platform_window_agl.h" + #include "base/component_export.h" + #include "ui/base/class_property.h" + #include "ui/base/ui_base_types.h" +@@ -32,7 +33,8 @@ class PlatformCursor; + + // Generic PlatformWindow interface. + class COMPONENT_EXPORT(PLATFORM_WINDOW) PlatformWindow +- : public PropertyHandler { ++ : public PropertyHandler, ++ public PlatformWindowAgl { + public: + PlatformWindow(); + ~PlatformWindow() override; +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0007-Only-bind-to-agl_shell-if-it-s-the-browser-process.patch b/recipes-wam/cef/files/chromium/0007-Only-bind-to-agl_shell-if-it-s-the-browser-process.patch new file mode 100644 index 000000000..8961b4649 --- /dev/null +++ b/recipes-wam/cef/files/chromium/0007-Only-bind-to-agl_shell-if-it-s-the-browser-process.patch @@ -0,0 +1,39 @@ +From 1b60d7d98be14175b5175ee6ba4c19da03d8188e Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Sat, 27 May 2023 15:55:17 +0200 +Subject: [PATCH 7/9] Only bind to agl_shell if it's the browser process + +--- + .../extensions/agl/host/wayland_extensions_agl_impl.cc | 9 +++++++-- + 1 file changed, 7 insertions(+), 2 deletions(-) + +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +index 87376cbb8a9d3..075b3010ea8a1 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +@@ -20,6 +20,7 @@ + + #include "base/command_line.h" + #include "base/logging.h" ++#include "content/public/common/content_switches.h" + #include "ui/base/ui_base_switches.h" + #include "ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h" + #include "ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h" +@@ -45,8 +46,12 @@ bool WaylandExtensionsAglImpl::Bind(wl_registry* registry, + uint32_t name, + const char* interface, + uint32_t version) { +- bool should_use_agl_shell = base::CommandLine::ForCurrentProcess()->HasSwitch( +- switches::kAglShellAppId); ++ bool has_agl_shell_switch = base::CommandLine::ForCurrentProcess()->HasSwitch( ++ switches::kAglShellAppId); ++ bool is_browser_process = !base::CommandLine::ForCurrentProcess()->HasSwitch( ++ switches::kProcessType); ++ bool should_use_agl_shell = has_agl_shell_switch && is_browser_process; ++ + bool can_bind = wl::CanBind(interface, version, kMinAglShellExtensionVersion, + kMaxAglShellExtensionVersion); + bool is_agl_shell_interface = (strcmp(interface, "agl_shell") == 0); +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0008-Add-a-method-to-check-if-the-agl-window-is-configure.patch b/recipes-wam/cef/files/chromium/0008-Add-a-method-to-check-if-the-agl-window-is-configure.patch new file mode 100644 index 000000000..bae799d7b --- /dev/null +++ b/recipes-wam/cef/files/chromium/0008-Add-a-method-to-check-if-the-agl-window-is-configure.patch @@ -0,0 +1,64 @@ +From d76f1575fd5abd31d488f7456700af0ead9712f0 Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Fri, 30 Jun 2023 10:25:10 +0200 +Subject: [PATCH 8/9] Add a method to check if the agl window is configured + +--- + ui/aura/agl/window_tree_host_agl.h | 1 + + ui/aura/agl/window_tree_host_platform_agl.cc | 4 ++++ + ui/aura/agl/window_tree_host_platform_agl.h | 1 + + ui/platform_window/agl/platform_window_agl.h | 1 + + 4 files changed, 7 insertions(+) + +diff --git a/ui/aura/agl/window_tree_host_agl.h b/ui/aura/agl/window_tree_host_agl.h +index 858a078d939d0..b9aa451c8332e 100644 +--- a/ui/aura/agl/window_tree_host_agl.h ++++ b/ui/aura/agl/window_tree_host_agl.h +@@ -35,6 +35,7 @@ class AURA_EXPORT WindowTreeHostAgl { + virtual void SetAglReady() {} + virtual void SetAglBackground() {} + virtual void SetAglPanel(uint32_t edge) {} ++ virtual bool IsSurfaceConfigured() const { return false; } + }; + + } // namespace aura +diff --git a/ui/aura/agl/window_tree_host_platform_agl.cc b/ui/aura/agl/window_tree_host_platform_agl.cc +index e34595fe0ed9c..67190e1da6973 100644 +--- a/ui/aura/agl/window_tree_host_platform_agl.cc ++++ b/ui/aura/agl/window_tree_host_platform_agl.cc +@@ -47,4 +47,8 @@ void WindowTreeHostPlatformAgl::SetAglPanel(uint32_t edge) { + window_tree_host_platform_->platform_window()->SetAglPanel(edge); + } + ++bool WindowTreeHostPlatformAgl::IsSurfaceConfigured() const { ++ return window_tree_host_platform_->platform_window()->IsSurfaceConfigured(); ++} ++ + } // namespace aura +diff --git a/ui/aura/agl/window_tree_host_platform_agl.h b/ui/aura/agl/window_tree_host_platform_agl.h +index 181eefae346f7..e5a29fa1bfca3 100644 +--- a/ui/aura/agl/window_tree_host_platform_agl.h ++++ b/ui/aura/agl/window_tree_host_platform_agl.h +@@ -41,6 +41,7 @@ class AURA_EXPORT WindowTreeHostPlatformAgl : public aura::WindowTreeHost { + void SetAglReady() override; + void SetAglBackground() override; + void SetAglPanel(uint32_t edge) override; ++ bool IsSurfaceConfigured() const override; + + private: + aura::WindowTreeHostPlatform* window_tree_host_platform_; +diff --git a/ui/platform_window/agl/platform_window_agl.h b/ui/platform_window/agl/platform_window_agl.h +index 4bc915d663e72..cab1f42272772 100644 +--- a/ui/platform_window/agl/platform_window_agl.h ++++ b/ui/platform_window/agl/platform_window_agl.h +@@ -29,6 +29,7 @@ class PlatformWindowAgl { + virtual void SetAglReady() {} + virtual void SetAglBackground() {} + virtual void SetAglPanel(uint32_t edge) {} ++ virtual bool IsSurfaceConfigured() { return false; } + }; + + } // namespace ui +-- +2.39.2 + diff --git a/recipes-wam/cef/files/chromium/0009-Start-using-agl-shell-version-4.patch b/recipes-wam/cef/files/chromium/0009-Start-using-agl-shell-version-4.patch new file mode 100644 index 000000000..1cf91430d --- /dev/null +++ b/recipes-wam/cef/files/chromium/0009-Start-using-agl-shell-version-4.patch @@ -0,0 +1,347 @@ +From 87e8811a2fc95b57f958e2bdfe5f3e434ecbff1e Mon Sep 17 00:00:00 2001 +From: Roger Zanoni <rzanoni@igalia.com> +Date: Sun, 2 Jul 2023 11:11:07 +0200 +Subject: [PATCH 9/9] Start using agl-shell version 4 + +--- + ui/aura/agl/window_tree_host_agl.h | 1 + + ui/aura/agl/window_tree_host_platform_agl.cc | 4 + + ui/aura/agl/window_tree_host_platform_agl.h | 1 + + .../extensions/agl/host/agl_shell_wrapper.cc | 9 + + .../extensions/agl/host/agl_shell_wrapper.h | 1 + + .../agl/host/wayland_extensions_agl_impl.cc | 2 +- + .../extensions/agl/host/wayland_window_agl.cc | 10 + + .../extensions/agl/host/wayland_window_agl.h | 1 + + .../extensions/agl/protocol/agl-shell.xml | 185 +++++++++++++++++- + ui/platform_window/agl/platform_window_agl.h | 1 + + 10 files changed, 213 insertions(+), 2 deletions(-) + +diff --git a/ui/aura/agl/window_tree_host_agl.h b/ui/aura/agl/window_tree_host_agl.h +index b9aa451c8332e..c5213f75e623e 100644 +--- a/ui/aura/agl/window_tree_host_agl.h ++++ b/ui/aura/agl/window_tree_host_agl.h +@@ -36,6 +36,7 @@ class AURA_EXPORT WindowTreeHostAgl { + virtual void SetAglBackground() {} + virtual void SetAglPanel(uint32_t edge) {} + virtual bool IsSurfaceConfigured() const { return false; } ++ virtual void SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {} + }; + + } // namespace aura +diff --git a/ui/aura/agl/window_tree_host_platform_agl.cc b/ui/aura/agl/window_tree_host_platform_agl.cc +index 67190e1da6973..b9bae3f3b9bdc 100644 +--- a/ui/aura/agl/window_tree_host_platform_agl.cc ++++ b/ui/aura/agl/window_tree_host_platform_agl.cc +@@ -51,4 +51,8 @@ bool WindowTreeHostPlatformAgl::IsSurfaceConfigured() const { + return window_tree_host_platform_->platform_window()->IsSurfaceConfigured(); + } + ++void WindowTreeHostPlatformAgl::SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) { ++ window_tree_host_platform_->platform_window()->SetupActivationArea(x, y, width, height); ++} ++ + } // namespace aura +diff --git a/ui/aura/agl/window_tree_host_platform_agl.h b/ui/aura/agl/window_tree_host_platform_agl.h +index e5a29fa1bfca3..30e160736e327 100644 +--- a/ui/aura/agl/window_tree_host_platform_agl.h ++++ b/ui/aura/agl/window_tree_host_platform_agl.h +@@ -42,6 +42,7 @@ class AURA_EXPORT WindowTreeHostPlatformAgl : public aura::WindowTreeHost { + void SetAglBackground() override; + void SetAglPanel(uint32_t edge) override; + bool IsSurfaceConfigured() const override; ++ void SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) override; + + private: + aura::WindowTreeHostPlatform* window_tree_host_platform_; +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc +index c74fa5d9cd221..0d5d79c4738df 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc ++++ b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.cc +@@ -110,4 +110,13 @@ bool AglShellWrapper::WaitUntilBoundOk() { + return bound_ok_; + } + ++void AglShellWrapper::SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) { ++#ifdef AGL_SHELL_SET_ACTIVATE_REGION_SINCE_VERSION ++ wl_output* output = ++ connection_->wayland_output_manager()->GetPrimaryOutput()->get_output(); ++ agl_shell_set_activate_region(agl_shell_.get(), output, x, y, ++ width, height); ++#endif ++} ++ + } // namespace ui +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h +index 2ab765883057e..1c2074e1b4306 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h ++++ b/ui/ozone/platform/wayland/extensions/agl/host/agl_shell_wrapper.h +@@ -39,6 +39,7 @@ class AglShellWrapper { + void SetAglPanel(WaylandWindow* window, uint32_t edge); + void SetAglBackground(WaylandWindow* window); + void SetAglReady(); ++ void SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height); + bool WaitUntilBoundOk(); + + static void AglShellBoundOk(void* data, struct agl_shell*); +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +index 075b3010ea8a1..8f9d938cdd1f6 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_extensions_agl_impl.cc +@@ -32,7 +32,7 @@ namespace ui { + namespace { + + constexpr uint32_t kMinAglShellExtensionVersion = 1; +-constexpr uint32_t kMaxAglShellExtensionVersion = 3; ++constexpr uint32_t kMaxAglShellExtensionVersion = 4; + + } // namespace + +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc +index 97b21ae537658..f92406d455de1 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.cc +@@ -83,4 +83,14 @@ void WaylandWindowAgl::SetAglPanel(uint32_t edge) { + connection()->ScheduleFlush(); + } + ++void WaylandWindowAgl::SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) { ++ if (!agl_extensions_->GetAglShell()) { ++ LOG(ERROR) << "Agl shell wrapper is not created"; ++ return; ++ } ++ ++ agl_extensions_->GetAglShell()->SetupActivationArea(x, y, width, height); ++ connection()->ScheduleFlush(); ++} ++ + } // namespace ui +diff --git a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h +index b2a922604c001..d21d2d9387215 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h ++++ b/ui/ozone/platform/wayland/extensions/agl/host/wayland_window_agl.h +@@ -39,6 +39,7 @@ class WaylandWindowAgl : public WaylandToplevelWindow { + void SetAglReady() override; + void SetAglBackground() override; + void SetAglPanel(uint32_t edge) override; ++ void SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) override; + + private: + WaylandExtensionsAgl* agl_extensions_; +diff --git a/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml b/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml +index ad5553d61f189..e010a80808c69 100644 +--- a/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml ++++ b/ui/ozone/platform/wayland/extensions/agl/protocol/agl-shell.xml +@@ -22,7 +22,7 @@ + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + </copyright> +- <interface name="agl_shell" version="3"> ++ <interface name="agl_shell" version="8"> + <description summary="user interface for Automotive Grade Linux platform"> + Starting with version 2 of the protocol, the client is required to wait + for the 'bound_ok' or 'bound_fail' events in order to proceed further. +@@ -174,6 +174,189 @@ + <arg name="state" type="uint" enum="app_state"/> + </event> + ++ <request name="set_activate_region" since="4"> ++ <description summary="sets a specific region to activate"> ++ A hint for the compositor to use a custom area, rather than ++ inferring the activation area. If any panels are used ++ the compositor computes the activation area by subtracting the ++ panels geometry area. If no panels are used then the entire output ++ is being used. This request changes that as to hint the compositor ++ to use the supplied rectangle and ignore any potential panels ++ that might been set-up previously. + ++ In order for this request to take effect it will need to happen ++ before the 'ready' request in order for the compositor to make use of it. ++ Note that any 'set_panel' request be will not be honored, if this request ++ has been called. ++ ++ The x and y coordinates use the top-left corner as the origin. The ++ rectangle area shouldn't exceed the output area, while an area smaller ++ than the output, would basically result in showing up the background ++ surface. ++ </description> ++ <arg name="output" type="object" interface="wl_output"/> ++ <arg name="x" type="int" summary="x position of rectangle"/> ++ <arg name="y" type="int" summary="y position of rectangle"/> ++ <arg name="width" type="int" summary="width of rectangle"/> ++ <arg name="height" type="int" summary="height of rectangle"/> ++ </request> ++ ++ <request name="deactivate_app" since="5"> ++ <description summary="de-activate/hide window identified by app_id"> ++ Ask the compositor to hide the toplevel window for window ++ management purposes. Depending on the window role, this request ++ will either display the previously active window (or the background ++ in case there's no previously active surface) or temporarily (or ++ until a 'activate_app' is called upon) hide the surface. ++ ++ All the surfaces are identifiable by using the app_id, and no actions ++ are taken in case the app_id is not/was not present. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ </description> ++ <arg name="app_id" type="string"/> ++ </request> ++ ++ <request name="set_app_float" since="6"> ++ <description summary="set the window identified by app_id as float"> ++ Makes the application identified by app_id as floating. If the ++ application's window is already mapped, in a maximized, normal state, ++ it would transition to the float state. ++ ++ For applications that want to modify their own state, this request ++ must be done before the initial surface commit in order to take effect. ++ ++ If the application is already in floating state, this request wouldn't ++ do anything. ++ ++ There's no persistence of this request, once the application terminated ++ you'll to issue this request again for that particular app_id. ++ ++ The x, and y values would be initial position of the window where the ++ window surface will be placed. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ </description> ++ <arg name="app_id" type="string"/> ++ <arg name="x" type="int" summary="x position"/> ++ <arg name="y" type="int" summary="y position"/> ++ </request> ++ ++ <request name="set_app_normal" since="6"> ++ <description summary="set the window identified by app_id as normally started"> ++ Returns the application identified by app_id as it was in the normal state. ++ This is useful to come back from other states to the maximized state, the ++ normal state applications are started. ++ </description> ++ <arg name="app_id" type="string"/> ++ </request> ++ ++ <request name="set_app_fullscreen" since="7"> ++ <description summary=""> ++ Makes the application identified by app_id as fullscreen. If the ++ application's window is already mapped, in a maximized, normal state, ++ it would transition to the fullscreen state. ++ ++ For applications that want to modify their own state, this request ++ must be done before the initial surface commit in order to take effect. ++ ++ If the application is already in fullscreen state, this request wouldn't ++ do anything. ++ ++ There's no persistence of this request, once the application terminated ++ you'll to issue this request again for that particular app_id. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ </description> ++ <arg name="app_id" type="string"/> ++ </request> ++ ++ <request name="set_app_output" since="8"> ++ <description summary="Assign an application to a particular output"> ++ This would allow the compositor to place an application on a particular ++ output, if that output is indeed available. This can happen before ++ application is started which would make the application start on that ++ particular output. If the application is already started it would ++ move the application to that output. ++ ++ There's no persistence of this request, once the application terminated ++ you'll need to issue this request again for that particular app_id. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ </description> ++ <arg name="app_id" type="string"/> ++ <arg name="output" type="object" interface="wl_output"/> ++ </request> ++ ++ <event name="app_on_output" since="8"> ++ <description summary="Event sent as a reponse to set_app_output"> ++ Clients can use this event to be notified when an application ++ wants to be displayed on a certain output. This event is sent in ++ response to the set_app_output request. ++ ++ See xdg_toplevel.set_app_id from the xdg-shell protocol for a ++ description of app_id. ++ </description> ++ <arg name="app_id" type="string"/> ++ <arg name="output_name" type="string"/> ++ </event> ++ </interface> ++ ++ <interface name="agl_shell_ext" version="1"> ++ <description summary="extended user interface for Automotive Grade Linux platform"> ++ This interface allows another client bind to the agl_shell interface, ++ while there's another shell client already present. ++ ++ The client should first bind to this interface and then inform the ++ compositor with the 'doas_shell_client' request and it wants to bind to ++ the agl_shell interface. The client is still expected, if using a new ++ version of the agl_shell interface, to wait for the 'bound_ok' and ++ 'bound_fail' events before issueing any other requests/events. ++ ++ Note that this interface has its limitations, and the compositor would ++ still refuse the act for 'set_panel' or 'set_background' requests ++ of the agl_shell interface if there's already a client that used them. ++ ++ Any other requests or events should be delievered and handled as it would ++ a client bound to the agl_shell interface. ++ </description> ++ ++ <enum name="doas_shell_client_status"> ++ <entry name="success" value="0"/> ++ <entry name="failed" value="1"/> ++ </enum> ++ ++ <request name="destroy" type="destructor"> ++ <description summary="destroys the factory object"> ++ Call the destructor once you're ready with agl_shell_ext interface. ++ This would reset the state and would make any requests made ++ on the agl_shell interface be terminated. The client would need ++ to bind again the agl_shell_ext and issue a 'doas_shell_client' ++ request. ++ </description> ++ </request> ++ ++ <request name="doas_shell_client"> ++ <description summary="Informs the compositor it wants to bind to the ++ agl_shell interface"> ++ Prior to binding to agl_shell interface, this request would inform ++ the compositor that it wants to gain access the agl_shell interface. ++ The client is expected to wait for 'doas_shell_client_done' event and ++ check for a successful status before going further with binding to ++ the agl_shell interface. ++ </description> ++ </request> ++ ++ <event name="doas_done"> ++ <description summary="event sent as a reply to doas_shell_client"> ++ The client should check the status event to verify that the ++ compositor was able to handle the request. ++ </description> ++ <arg name="status" type="uint" enum="doas_shell_client_status"/> ++ </event> + </interface> + </protocol> +diff --git a/ui/platform_window/agl/platform_window_agl.h b/ui/platform_window/agl/platform_window_agl.h +index cab1f42272772..b1a6150fff950 100644 +--- a/ui/platform_window/agl/platform_window_agl.h ++++ b/ui/platform_window/agl/platform_window_agl.h +@@ -30,6 +30,7 @@ class PlatformWindowAgl { + virtual void SetAglBackground() {} + virtual void SetAglPanel(uint32_t edge) {} + virtual bool IsSurfaceConfigured() { return false; } ++ virtual void SetupActivationArea(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {} + }; + + } // namespace ui +-- +2.39.2 + |