sommelier-window-test.cc

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

#include "mock-viewporter-shim.h"  // NOLINT(build/include_directory)
#include "testing/x11-test-base.h"

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <wayland-client-protocol.h>
#include <wayland-client.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol.h>
#include <wayland-util.h>
#include <xcb/xcb.h>
#include <xcb/xproto.h>
#include <cstdint>

#ifdef QUIRKS_SUPPORT
#include "quirks/sommelier-quirks.h"
#endif

namespace vm_tools {
namespace sommelier {

using ::testing::_;
using ::testing::AllOf;
using ::testing::PrintToString;

using X11Test = X11TestBase;

TEST_F(X11DirectScaleTest, ViewportOverrideStretchedVertically) {
  // Arrange
  ctx.viewport_resize = true;
  AdvertiseOutputs(xwayland.get(),
                   {{.logical_width = 1536, .logical_height = 864}});
  sl_window* window = CreateToplevelWindow();
  const int pixel_width = 1920;
  const int pixel_height = 1080;
  window->managed = true;
  window->max_width = pixel_width;
  window->min_height = pixel_height;
  window->min_width = pixel_width;
  window->max_height = pixel_height;
  window->width = pixel_width;
  window->height = pixel_height;
  window->paired_surface->contents_width = pixel_width;
  window->paired_surface->contents_height = pixel_height;
  wl_array states;
  wl_array_init(&states);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1393, 784))
      .Times(1);

  // Act: Configure with height smaller than min_height.
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1536 /*1920*/, 784 /*980*/,
                  &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123);
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport size and pointer scale are set, width height are
  // unchanged.
  EXPECT_TRUE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, 1393);
  EXPECT_EQ(window->viewport_height, 784);
  EXPECT_FLOAT_EQ(window->viewport_pointer_scale, 1.1026561);
  EXPECT_EQ(window->width, 1920);
  EXPECT_EQ(window->height, 1080);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, -1, -1))
      // Act: Configure with the size that is within the window bounds.
      .Times(1);
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1536, 864, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 124);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1536, 864))
      .Times(1);

  // Act
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport override is no longer used.
  EXPECT_FALSE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, -1);
  EXPECT_EQ(window->viewport_height, -1);
  EXPECT_EQ(window->width, pixel_width);
  EXPECT_EQ(window->height, pixel_height);
}

TEST_F(X11DirectScaleTest, ViewportOverrideStretchedHorizontally) {
  // Arrange
  ctx.viewport_resize = true;
  AdvertiseOutputs(xwayland.get(),
                   {{.logical_width = 1536, .logical_height = 864}});
  sl_window* window = CreateToplevelWindow();
  window->managed = true;
  window->max_width = 1700;
  window->max_height = 900;
  window->min_width = 1600;
  window->min_height = 800;
  window->width = 1650;
  window->height = 800;
  window->paired_surface->contents_width = 1650;
  window->paired_surface->contents_height = 800;
  wl_array states;
  wl_array_init(&states);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1200, 581))
      .Times(1);

  // Act: Height is set to equal to max height, width smaller than min
  // width.
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1200 /*1500*/, 720 /*900*/,
                  &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123);
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport size and pointer scale are set, width height are
  // unchanged.
  EXPECT_TRUE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, 1200);
  EXPECT_EQ(window->viewport_height, 581);
  EXPECT_FLOAT_EQ(window->viewport_pointer_scale, 1.1);
  EXPECT_EQ(window->width, 1650);
  EXPECT_EQ(window->height, 800);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, -1, -1))
      .Times(1);

  // Act: Configure with the size that is within the window bounds.
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1360 /*1700*/, 680 /*850*/,
                  &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 124);
  window->paired_surface->contents_width = 1700;
  window->paired_surface->contents_height = 850;

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1360, 680))
      .Times(1);

  // Act
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport override is no longer used.
  EXPECT_FALSE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, -1);
  EXPECT_EQ(window->viewport_height, -1);
  EXPECT_EQ(window->width, 1700);
  EXPECT_EQ(window->height, 850);
}

TEST_F(X11DirectScaleTest, ViewportOverrideSameAspectRatio) {
  // Arrange
  ctx.viewport_resize = true;
  AdvertiseOutputs(xwayland.get(),
                   {{.logical_width = 1536, .logical_height = 864}});
  sl_window* window = CreateToplevelWindow();
  window->managed = true;
  const int pixel_width = 1920;
  const int pixel_height = 1080;
  window->max_width = pixel_width;
  window->min_height = pixel_height;
  window->min_width = pixel_width;
  window->max_height = pixel_height;
  window->paired_surface->contents_width = pixel_width;
  window->paired_surface->contents_height = pixel_height;
  window->width = pixel_width;
  window->height = pixel_height;
  wl_array states;
  wl_array_init(&states);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1280, 720))
      .Times(1);

  // Act: Height and width squished while maintaining aspect ratio.
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1280 /*1600*/, 720 /*900*/,
                  &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123);
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport size and pointer scale are set, width height are
  // unchanged.
  EXPECT_TRUE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, 1280);
  EXPECT_EQ(window->viewport_height, 720);
  EXPECT_FLOAT_EQ(window->viewport_pointer_scale, 1.2);
  EXPECT_EQ(window->width, pixel_width);
  EXPECT_EQ(window->height, pixel_height);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, -1, -1))
      .Times(1);

  // Act: Configure with the size that is within the window bounds.
  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 1536, 864, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123);

  // Assert
  EXPECT_CALL(mock_viewport_shim_,
              set_destination(window->paired_surface->viewport, 1536, 864))
      .Times(1);

  // Act
  sl_host_surface_commit(nullptr, window->paired_surface->resource);
  Pump();

  // Assert: viewport override is no longer used.
  EXPECT_FALSE(window->viewport_override);
  EXPECT_EQ(window->viewport_width, -1);
  EXPECT_EQ(window->viewport_height, -1);
  EXPECT_EQ(window->width, 1920);
  EXPECT_EQ(window->height, 1080);
}

TEST_F(X11Test, TogglesFullscreenOnWmStateFullscreen) {
  // Arrange: Create an xdg_toplevel surface. Initially it's not fullscreen.
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  uint32_t xdg_toplevel_id = XdgToplevelId(window);
  EXPECT_EQ(window->fullscreen, 0);
  Pump();  // exclude pending messages from EXPECT_CALL()s below

  // Act: Pretend the window is owned by an X11 client requesting fullscreen.
  // Sommelier receives the XCB_CLIENT_MESSAGE request due to its role as the
  // X11 window manager. For test purposes, we skip creating a real X11
  // connection and just call directly into the relevant handler.
  xcb_client_message_event_t event;
  event.response_type = XCB_CLIENT_MESSAGE;
  event.format = 32;
  event.window = window->id;
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_ADD;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_FULLSCREEN].value;
  event.data.data32[2] = 0;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier records the fullscreen state.
  EXPECT_EQ(window->fullscreen, 1);
  // Assert: Sommelier forwards the fullscreen request to Exo.
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_FULLSCREEN)))
      .RetiresOnSaturation();
  Pump();

  // Act: Pretend the fictitious X11 client requests non-fullscreen.
  event.data.data32[0] = NET_WM_STATE_REMOVE;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier records the fullscreen state.
  EXPECT_EQ(window->fullscreen, 0);
  // Assert: Sommelier forwards the unfullscreen request to Exo.
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_UNSET_FULLSCREEN)))
      .RetiresOnSaturation();
}

TEST_F(X11Test, TogglesMaximizeOnWmStateMaximize) {
  // Arrange: Create an xdg_toplevel surface. Initially it's not maximized.
  sl_window* window = CreateToplevelWindow();
  uint32_t xdg_toplevel_id = XdgToplevelId(window);
  EXPECT_EQ(window->maximized, 0);
  Pump();  // exclude pending messages from EXPECT_CALL()s below

  // Act: Pretend an X11 client owns the surface, and requests to maximize it.
  xcb_client_message_event_t event;
  event.response_type = XCB_CLIENT_MESSAGE;
  event.format = 32;
  event.window = window->id;
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_ADD;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value;
  event.data.data32[2] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier records the maximized state + forwards to Exo.
  EXPECT_EQ(window->maximized, 1);
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_MAXIMIZED)))
      .RetiresOnSaturation();
  Pump();

  // Act: Pretend the fictitious X11 client requests to unmaximize.
  event.data.data32[0] = NET_WM_STATE_REMOVE;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier records the unmaximized state + forwards to Exo.
  EXPECT_EQ(window->maximized, 0);
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_UNSET_MAXIMIZED)))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, CanEnterFullscreenIfAlreadyMaximized) {
  // Arrange
  sl_window* window = CreateToplevelWindow();
  uint32_t xdg_toplevel_id = XdgToplevelId(window);
  Pump();  // exclude pending messages from EXPECT_CALL()s below

  // Act: Pretend an X11 client owns the surface, and requests to maximize it.
  xcb_client_message_event_t event;
  event.response_type = XCB_CLIENT_MESSAGE;
  event.format = 32;
  event.window = window->id;
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_ADD;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value;
  event.data.data32[2] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier records the maximized state + forwards to Exo.
  EXPECT_EQ(window->maximized, 1);
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_MAXIMIZED)))
      .RetiresOnSaturation();
  Pump();

  // Act: Pretend the X11 client requests fullscreen.
  xcb_client_message_event_t fsevent;
  fsevent.response_type = XCB_CLIENT_MESSAGE;
  fsevent.format = 32;
  fsevent.window = window->id;
  fsevent.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  fsevent.data.data32[0] = NET_WM_STATE_ADD;
  fsevent.data.data32[1] = 0;
  fsevent.data.data32[2] = ctx.atoms[ATOM_NET_WM_STATE_FULLSCREEN].value;
  fsevent.data.data32[3] = 0;
  fsevent.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &fsevent);

  // Assert: Sommelier records the fullscreen state + forwards to Exo.
  EXPECT_EQ(window->fullscreen, 1);
  EXPECT_CALL(
      mock_wayland_channel_,
      send(ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_FULLSCREEN)))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, UpdatesApplicationIdFromContext) {
  sl_window* window = CreateToplevelWindow();
  Pump();

  window->managed = 1;  // pretend window is mapped
  // Should be ignored; global app id from context takes priority.
  window->app_id_property = "org.chromium.guest_os.termina.appid.from.window";

  ctx.application_id = "org.chromium.guest_os.termina.appid.from.context";
  sl_update_application_id(&ctx, window);
  EXPECT_CALL(mock_wayland_channel_,
              send(AllOf(ExactlyOneMessage(AuraSurfaceId(window),
                                           ZAURA_SURFACE_SET_APPLICATION_ID),
                         AnyMessageContainsString(ctx.application_id))))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, UpdatesApplicationIdFromWindow) {
  sl_window* window = CreateToplevelWindow();
  Pump();

  window->managed = 1;  // pretend window is mapped
  window->app_id_property = "org.chromium.guest_os.termina.appid.from.window";
  sl_update_application_id(&ctx, window);
  EXPECT_CALL(mock_wayland_channel_,
              send(AllOf(ExactlyOneMessage(AuraSurfaceId(window),
                                           ZAURA_SURFACE_SET_APPLICATION_ID),
                         AnyMessageContainsString(window->app_id_property))))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, UpdatesApplicationIdFromWindowClass) {
  sl_window* window = CreateToplevelWindow();
  Pump();

  window->managed = 1;                    // pretend window is mapped
  window->clazz = strdup("very_classy");  // not const, can't use a literal
  ctx.vm_id = "testvm";
  sl_update_application_id(&ctx, window);
  EXPECT_CALL(
      mock_wayland_channel_,
      send(AllOf(ExactlyOneMessage(AuraSurfaceId(window),
                                   ZAURA_SURFACE_SET_APPLICATION_ID),
                 AnyMessageContainsString(
                     "org.chromium.guest_os.testvm.wmclass.very_classy"))))
      .RetiresOnSaturation();
  Pump();
  free(window->clazz);
}

TEST_F(X11Test, UpdatesApplicationIdFromClientLeader) {
  sl_window* window = CreateToplevelWindow();
  Pump();

  window->managed = 1;  // pretend window is mapped
  window->client_leader = window->id;
  ctx.vm_id = "testvm";
  sl_update_application_id(&ctx, window);
  EXPECT_CALL(mock_wayland_channel_,
              send(AllOf(ExactlyOneMessage(AuraSurfaceId(window),
                                           ZAURA_SURFACE_SET_APPLICATION_ID),
                         AnyMessageContainsString(
                             "org.chromium.guest_os.testvm.wmclientleader."))))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, UpdatesApplicationIdFromXid) {
  sl_window* window = CreateToplevelWindow();
  Pump();

  window->managed = 1;  // pretend window is mapped
  ctx.vm_id = "testvm";
  sl_update_application_id(&ctx, window);
  EXPECT_CALL(mock_wayland_channel_,
              send(AllOf(ExactlyOneMessage(AuraSurfaceId(window),
                                           ZAURA_SURFACE_SET_APPLICATION_ID),
                         AnyMessageContainsString(
                             "org.chromium.guest_os.testvm.xid."))))
      .RetiresOnSaturation();
  Pump();
}

TEST_F(X11Test, NonExistentWindowDoesNotCrash) {
  // This test is testing cases where sl_lookup_window returns nullptr

  // sl_handle_destroy_notify
  xcb_destroy_notify_event_t destroy_event;
  // Arrange: Use a window that does not exist.
  destroy_event.window = 123;
  // Act/Assert: Sommelier does not crash.
  sl_handle_destroy_notify(&ctx, &destroy_event);

  // sl_handle_client_message
  xcb_client_message_event_t message_event;
  message_event.window = 123;
  message_event.data.data32[0] = WM_STATE_ICONIC;
  message_event.type = ctx.atoms[ATOM_WL_SURFACE_ID].value;
  sl_handle_client_message(&ctx, &message_event);
  message_event.type = ctx.atoms[ATOM_NET_ACTIVE_WINDOW].value;
  sl_handle_client_message(&ctx, &message_event);
  message_event.type = ctx.atoms[ATOM_NET_WM_MOVERESIZE].value;
  sl_handle_client_message(&ctx, &message_event);
  message_event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  sl_handle_client_message(&ctx, &message_event);
  message_event.type = ctx.atoms[ATOM_WM_CHANGE_STATE].value;
  sl_handle_client_message(&ctx, &message_event);

  // sl_handle_map_request
  xcb_map_request_event_t map_event;
  map_event.window = 123;
  sl_handle_map_request(&ctx, &map_event);

  // sl_handle_unmap_notify
  xcb_unmap_notify_event_t unmap_event;
  unmap_event.window = 123;
  unmap_event.response_type = 0;
  sl_handle_unmap_notify(&ctx, &unmap_event);

  // sl_handle_configure_request
  xcb_configure_request_event_t configure_event;
  configure_event.window = 123;
  sl_handle_configure_request(&ctx, &configure_event);

  // sl_handle_focus_in
  xcb_focus_in_event_t focus_event;
  focus_event.event = 123;
  sl_handle_focus_in(&ctx, &focus_event);

  // sl_handle_property_notify
  xcb_property_notify_event_t notify_event;
  notify_event.window = 123;
  notify_event.atom = XCB_ATOM_WM_NAME;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = XCB_ATOM_WM_CLASS;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = ctx.application_id_property_atom;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = XCB_ATOM_WM_NORMAL_HINTS;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = XCB_ATOM_WM_HINTS;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = ATOM_MOTIF_WM_HINTS;
  sl_handle_property_notify(&ctx, &notify_event);
  notify_event.atom = ATOM_GTK_THEME_VARIANT;
  sl_handle_property_notify(&ctx, &notify_event);

  // sl_handle_reparent_notify
  // Put this one last and used a different window id as it creates a window.
  xcb_reparent_notify_event_t reparent_event;
  reparent_event.window = 1234;
  xcb_screen_t screen;
  screen.root = 1234;
  ctx.screen = &screen;
  reparent_event.parent = ctx.screen->root;
  reparent_event.x = 0;
  reparent_event.y = 0;
  sl_handle_reparent_notify(&ctx, &reparent_event);
}

#ifdef QUIRKS_SUPPORT
TEST_F(X11Test, IconifySuppressesFullscreen) {
  // Arrange: Create an xdg_toplevel surface. Initially it's not iconified.
  sl_window* window = CreateToplevelWindow();
  uint32_t xdg_toplevel_id = XdgToplevelId(window);
  EXPECT_EQ(window->iconified, 0);

  window->steam_game_id = 123;
  ctx.quirks.Load(
      "sommelier { \n"
      "  condition { steam_game_id: 123 }\n"
      "  enable: FEATURE_BLACK_SCREEN_FIX\n"
      "}");

  // Act: Pretend an X11 client owns the surface, and requests to iconify it.
  xcb_client_message_event_t event;
  event.response_type = XCB_CLIENT_MESSAGE;
  event.format = 32;
  event.window = window->id;
  event.type = ctx.atoms[ATOM_WM_CHANGE_STATE].value;
  event.data.data32[0] = WM_STATE_ICONIC;
  sl_handle_client_message(&ctx, &event);
  Pump();

  // Assert: Sommelier records the iconified state.
  EXPECT_EQ(window->iconified, 1);

  // Act: Pretend the surface is requested to be fullscreened.
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_ADD;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_FULLSCREEN].value;
  event.data.data32[2] = 0;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier should not send the fullscreen call as we are iconified.
  EXPECT_CALL(
      mock_wayland_channel_,
      send((ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_FULLSCREEN))))
      .Times(0);
  Pump();

  // Act: Pretend the surface receives focus.
  xcb_focus_in_event_t focus_event;
  focus_event.response_type = XCB_FOCUS_IN;
  focus_event.event = window->id;
  sl_handle_focus_in(&ctx, &focus_event);

  // Assert: The window is deiconified.
  EXPECT_EQ(window->iconified, 0);

  // Assert: Sommelier should now send the fullscreen call.
  EXPECT_CALL(
      mock_wayland_channel_,
      send((ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_SET_FULLSCREEN))))
      .Times(1);
  Pump();
}

TEST_F(X11Test, IconifySuppressesUnmaximize) {
  // Arrange: Create an xdg_toplevel surface. Initially it's not iconified.
  sl_window* window = CreateToplevelWindow();
  uint32_t xdg_toplevel_id = XdgToplevelId(window);
  EXPECT_EQ(window->iconified, 0);

  window->steam_game_id = 123;
  ctx.quirks.Load(
      "sommelier { \n"
      "  condition { steam_game_id: 123 }\n"
      "  enable: FEATURE_BLACK_SCREEN_FIX\n"
      "}");

  // Arrange: Maximize it.
  xcb_client_message_event_t event;
  event.response_type = XCB_CLIENT_MESSAGE;
  event.format = 32;
  event.window = window->id;
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_ADD;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value;
  event.data.data32[2] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);
  EXPECT_EQ(window->maximized, 1);

  // Act: Pretend an X11 client owns the surface, and requests to iconify it.
  event.type = ctx.atoms[ATOM_WM_CHANGE_STATE].value;
  event.data.data32[0] = WM_STATE_ICONIC;
  sl_handle_client_message(&ctx, &event);
  Pump();

  // Assert: Sommelier records the iconified state.
  EXPECT_EQ(window->iconified, 1);

  // Act: Pretend the surface is requested to be unmaximized.
  event.type = ctx.atoms[ATOM_NET_WM_STATE].value;
  event.data.data32[0] = NET_WM_STATE_REMOVE;
  event.data.data32[1] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT].value;
  event.data.data32[2] = ctx.atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ].value;
  event.data.data32[3] = 0;
  event.data.data32[4] = 0;
  sl_handle_client_message(&ctx, &event);

  // Assert: Sommelier should not send the unmiximize call as we are iconified.
  EXPECT_CALL(
      mock_wayland_channel_,
      send((ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_UNSET_MAXIMIZED))))
      .Times(0);
  Pump();

  // Act: Pretend the surface receives focus.
  xcb_focus_in_event_t focus_event;
  focus_event.response_type = XCB_FOCUS_IN;
  focus_event.event = window->id;
  sl_handle_focus_in(&ctx, &focus_event);

  // Assert: The window is deiconified.
  EXPECT_EQ(window->iconified, 0);

  // Assert: Sommelier should now send the unmiximize call.
  EXPECT_CALL(
      mock_wayland_channel_,
      send((ExactlyOneMessage(xdg_toplevel_id, XDG_TOPLEVEL_UNSET_MAXIMIZED))))
      .Times(1);
  Pump();
}
#endif  // QUIRKS_SUPPORT

// Matcher for the value_list argument of an X11 ConfigureWindow request,
// which is a const void* pointing to an int array whose size is implied by
// the flags argument.
MATCHER_P(ValueListMatches, expected, "") {
  const int* value_ptr = static_cast<const int*>(arg);
  std::vector<int> values;
  for (std::vector<int>::size_type i = 0; i < expected.size(); i++) {
    values.push_back(value_ptr[i]);
  }
  *result_listener << PrintToString(values);
  return values == expected;
}

// Matcher for the data argument of an X11 ChangeProperty request,
// which is a const void* pointing to an uint32_t array whose size is implied by
// the flags argument. Hence, this does not test if argument exceeds the size of
// expected since we have to explicitly state the size in the function call.
MATCHER_P(ChangePropertyDataMatches, expected, "") {
  const uint32_t* received = static_cast<const uint32_t*>(arg);
  for (uint32_t i = 0; i < expected.size(); i++) {
    if (received[i] != expected[i]) {
      return false;
    }
  }
  return true;
}

TEST_F(X11Test, XdgToplevelConfigureTriggersX11Configure) {
  // Arrange
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int width = 1024;
  const int height = 768;

  // Assert: Set up expectations for Sommelier to send appropriate X11 requests.
  // (output width/height - width/height) / 2
  int x = 448;
  int y = 156;
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->frame_id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({x, y, width, height, 0}))))
      .Times(1);
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({0, 0, width, height, 0}))))
      .Times(1);

  // Act: Pretend the host compositor sends us some xdg configure events.
  wl_array states;
  wl_array_init(&states);
  uint32_t* state =
      static_cast<uint32_t*>(wl_array_add(&states, sizeof(uint32_t)));
  *state = XDG_TOPLEVEL_STATE_ACTIVATED;

  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, width, height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123 /* serial */);
}

TEST_F(X11Test, XdgToplevelConfigureCentersWindowOnRotatedOutput) {
  // Arrange
  AdvertiseOutputs(xwayland.get(), {{.transform = WL_OUTPUT_TRANSFORM_90}});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int width = 1024;
  const int height = 768;

  // Assert: Set up expectations for Sommelier to send appropriate X11 requests.
  // (rotated output width/height - width/height) / 2
  int x = 28;
  int y = 576;
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->frame_id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({x, y, width, height, 0}))))
      .Times(1);
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({0, 0, width, height, 0}))))
      .Times(1);

  // Act: Pretend the host compositor sends us some xdg configure events.
  wl_array states;
  wl_array_init(&states);
  uint32_t* state =
      static_cast<uint32_t*>(wl_array_add(&states, sizeof(uint32_t)));
  *state = XDG_TOPLEVEL_STATE_ACTIVATED;

  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, width, height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123 /* serial */);
}

TEST_F(X11Test,
       XdgToplevelConfigureCentersWindowCorrectlyWhenMultipleOutputsExist) {
  // Arrange
  AdvertiseOutputs(
      xwayland.get(),
      {{.x = 0, .y = 0, .width_pixels = 1920, .height_pixels = 1080},
       {.x = 1920, .y = 500}});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int width = 1024;
  const int height = 768;
  struct sl_host_output* output = nullptr;
  output = ctx.host_outputs[1];
  HostEventHandler(window->paired_surface->proxy)
      ->enter(nullptr, window->paired_surface->proxy, output->proxy);

  // Assert: Set up expectations for Sommelier to send appropriate X11 requests.
  int x = 1920 + 448;
  int y = 156;
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->frame_id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({x, y, width, height, 0}))))
      .Times(1);
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({0, 0, width, height, 0}))))
      .Times(1);

  // Act: Pretend the host compositor sends us some xdg configure events.
  wl_array states;
  wl_array_init(&states);
  uint32_t* state =
      static_cast<uint32_t*>(wl_array_add(&states, sizeof(uint32_t)));
  *state = XDG_TOPLEVEL_STATE_ACTIVATED;

  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, width, height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123 /* serial */);
}

TEST_F(X11DirectScaleTest, AuraToplevelConfigureTriggersX11Configure) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int x = 50;
  const int y = 60;
  const int width = 1024;
  const int height = 768;

  // Assert: Set up expectations for Sommelier to send appropriate X11 requests.
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->frame_id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({x, y, width, height, 0}))))
      .Times(1);
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector({0, 0, width, height, 0}))))
      .Times(1);

  // Act: Pretend the host compositor sends us some configure events.
  wl_array states;
  wl_array_init(&states);
  uint32_t* state =
      static_cast<uint32_t*>(wl_array_add(&states, sizeof(uint32_t)));
  *state = XDG_TOPLEVEL_STATE_ACTIVATED;

  HostEventHandler(window->aura_toplevel)
      ->configure(nullptr, window->aura_toplevel, x, y, width, height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 123 /* serial */);
}

TEST_F(X11Test, AuraToplevelOriginChangeTriggersX11Configure) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int x = 50;
  const int y = 60;

  // Assert
  EXPECT_CALL(xcb, configure_window(testing::_, window->frame_id,
                                    XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,
                                    ValueListMatches(std::vector({x, y}))))
      .Times(1);

  // Act
  HostEventHandler(window->aura_toplevel)
      ->origin_change(nullptr, window->aura_toplevel, x, y);
}

// When the host compositor sends a window position, make sure we don't send
// a bounds request back. Otherwise we get glitching due to rounding and race
// conditions.
TEST_F(X11Test, AuraToplevelOriginChangeDoesNotRoundtrip) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;     // pretend window is mapped
  window->size_flags = 0;  // no hinted position or size
  const int x = 50;
  const int y = 60;

  // Assert: set_window_bounds() never sent.
  EXPECT_CALL(mock_wayland_channel_,
              send(testing::Not(AtLeastOneMessage(
                  AuraToplevelId(window), ZAURA_TOPLEVEL_SET_WINDOW_BOUNDS))))
      .Times(testing::AtLeast(0));

  // Act
  HostEventHandler(window->aura_toplevel)
      ->origin_change(nullptr, window->aura_toplevel, x, y);
  Pump();
}

TEST_F(X11Test, X11ConfigureRequestPositionIsForwardedToAuraHost) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;  // pretend window is mapped
  Pump();               // discard Wayland requests sent in setup

  // Assert
  EXPECT_CALL(mock_wayland_channel_,
              send(AtLeastOneMessage(AuraToplevelId(window),
                                     ZAURA_TOPLEVEL_SET_WINDOW_BOUNDS)))
      .RetiresOnSaturation();

  // Act
  xcb_configure_request_event_t configure = {
      .response_type = XCB_CONFIGURE_REQUEST,
      .sequence = 123,
      .parent = window->frame_id,
      .window = window->id,
      .x = 10,
      .y = 20,
      .width = 300,
      .height = 400,
      .value_mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                    XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT};
  sl_handle_configure_request(&ctx, &configure);
  Pump();
}

TEST_F(X11Test,
       X11ConfigureRequestPositionForwardingIgnoresStaleAuraToplevelConfigure) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;  // pretend window is mapped
  const int width = 300;
  const int height = 400;

  // Position requested by the client.
  const int client_requested_x = 10;
  const int client_requested_y = 0;

  // Stale position received from the host compositor.
  const int stale_x = 50;
  const int stale_y = 60;

  // Host compositor's adjusted response to the client's request.
  // (In this scenario, it moved the window down so its server-side
  // decorations wouldn't be offscreen.)
  const int granted_x = client_requested_x;
  const int granted_y = 32;

  //
  // Assert
  //

  // Barrier should prevent forwarding the host's stale coords to the X server.
  EXPECT_CALL(
      xcb, configure_window(testing::_, window->frame_id, testing::_,
                            ValueListMatches(std::vector({stale_x, stale_y}))))
      .Times(0);

  // Do forward the correct coordinates to the X server.
  EXPECT_CALL(xcb, configure_window(
                       testing::_, window->frame_id,
                       XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                           XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
                           XCB_CONFIG_WINDOW_BORDER_WIDTH,
                       ValueListMatches(std::vector(
                           {granted_x, granted_y, width, height, 0}))))
      .Times(1);

  // The reparented child window may also get configured.
  // The details are not important for this test case.
  EXPECT_CALL(xcb,
              configure_window(testing::_, window->id, testing::_, testing::_))
      .Times(testing::AtLeast(0));

  //
  // Act
  //

  // An incoming ConfigureRequest sends set_window_bounds(), and sets up the
  // event barrier.
  xcb_configure_request_event_t configure = {
      .response_type = XCB_CONFIGURE_REQUEST,
      .sequence = 123,
      .parent = window->frame_id,
      .window = window->id,
      .x = client_requested_x,
      .y = client_requested_y,
      .width = width,
      .height = height,
      .value_mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
                    XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT};
  sl_handle_configure_request(&ctx, &configure);
  EXPECT_NE(window->configure_event_barrier, nullptr);

  // Meanwhile, host compositor is sending stale position data, both via the
  // regular configure sequence and via origin_change events.
  wl_array states;
  wl_array_init(&states);
  uint32_t* state =
      static_cast<uint32_t*>(wl_array_add(&states, sizeof(uint32_t)));
  *state = XDG_TOPLEVEL_STATE_ACTIVATED;

  uint32_t serial = 120;

  HostEventHandler(window->aura_toplevel)
      ->configure(nullptr, window->aura_toplevel, stale_x, stale_y, width,
                  height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, serial++);

  HostEventHandler(window->aura_toplevel)
      ->origin_change(nullptr, window->aura_toplevel, stale_x, stale_y);
  Pump();

  // Exo catches up to the set_window_bounds() request. It modifies the
  // requested coords slightly and returns them in a fresh configure sequence.
  HostEventHandler(window->aura_toplevel)
      ->configure(nullptr, window->aura_toplevel, granted_x, granted_y, width,
                  height, &states);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, serial++);

  // Exo catches up to the event barrier.
  HostEventHandler(window->configure_event_barrier)
      ->done(nullptr, window->configure_event_barrier, serial++);

  Pump();
}

TEST_F(X11Test, X11ConfigureRequestWithoutPositionIsNotForwardedToAuraHost) {
  // Arrange
  ctx.enable_x11_move_windows = true;
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  window->managed = 1;  // pretend window is mapped

  // Assert: set_window_bounds() never sent.
  EXPECT_CALL(mock_wayland_channel_,
              send(testing::Not(AtLeastOneMessage(
                  AuraToplevelId(window), ZAURA_TOPLEVEL_SET_WINDOW_BOUNDS))))
      .Times(testing::AtLeast(0));

  // Act
  xcb_configure_request_event_t configure = {
      .response_type = XCB_CONFIGURE_REQUEST,
      .sequence = 123,
      .parent = window->frame_id,
      .window = window->id,
      .width = 300,
      .height = 400,
      .value_mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT};
  sl_handle_configure_request(&ctx, &configure);
  Pump();
}

TEST_F(X11Test, X11OnlyClientCanExitFullScreenIfFlagSet) {
  // Arrange
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  // pretend window is mapped and fullscreen
  window->managed = 1;
  window->fullscreen = true;
  window->compositor_fullscreen = true;
  window->allow_resize = false;

  // No states from Wayland - which means non-fullscreen
  struct wl_array states;
  wl_array_init(&states);

  // Test with the flag set. X11 next_config.state is set to fullscreen to
  // retain fullscreen.
  ctx.only_client_can_exit_fullscreen = true;
  window->next_config.states_length = 0;

  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 800, 600, &states);

  // window->fullscreen is not updated by sl_internal_toplevel_configure.
  // It is done by X11 notifying property change, hence we only test
  // compositor_fullscreen here.
  ASSERT_EQ(window->next_config.states_length, 1);
  ASSERT_EQ(window->next_config.states[0],
            window->ctx->atoms[ATOM_NET_WM_STATE_FULLSCREEN].value);

  ASSERT_FALSE(window->compositor_fullscreen);
  ASSERT_FALSE(window->allow_resize);
}

TEST_F(X11Test, X11ExitFullScreenIfFlagNotSet) {
  // Arrange
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  // pretend window is mapped and fullscreen
  window->managed = 1;
  window->fullscreen = true;
  window->compositor_fullscreen = true;
  window->allow_resize = false;

  // No states from Wayland - which means non-fullscreen
  struct wl_array states;
  wl_array_init(&states);

  // Test with without flag set. X11 next_config.state no longer includes
  // fullscreen.
  ctx.only_client_can_exit_fullscreen = false;
  window->next_config.states_length = 0;

  HostEventHandler(window->xdg_toplevel)
      ->configure(nullptr, window->xdg_toplevel, 800, 600, &states);

  // Compositor will treat the window as non-fullscreen and allow resize.
  // Since no next_config is defined, follow up xcb()->change_property()
  // will be called without any states - indicating the window is no
  // longer fullscreen.
  ASSERT_EQ(window->next_config.states_length, 0);

  ASSERT_FALSE(window->compositor_fullscreen);
  ASSERT_TRUE(window->allow_resize);
}

TEST_F(X11Test, X11NextConfigFullscreenStateConsumedCorrectly) {
  // Arrange
  AdvertiseOutputs(xwayland.get(), {OutputConfig()});
  sl_window* window = CreateToplevelWindow();
  // pretend window is mapped and fullscreen
  window->managed = 1;
  window->fullscreen = true;
  window->compositor_fullscreen = true;
  window->allow_resize = false;

  // set fullscreen
  window->next_config.states_length = 1;
  window->next_config.states[0] =
      window->ctx->atoms[ATOM_NET_WM_STATE_FULLSCREEN].value;

  EXPECT_CALL(xcb, change_property(
                       testing::_, XCB_PROP_MODE_REPLACE, window->id,
                       ctx.atoms[ATOM_NET_WM_STATE].value, XCB_ATOM_ATOM, 32, 1,
                       ChangePropertyDataMatches(std::vector(
                           {ctx.atoms[ATOM_NET_WM_STATE_FULLSCREEN].value}))))
      .Times(1);
  HostEventHandler(window->xdg_surface)
      ->configure(nullptr, window->xdg_surface, 0);
  Pump();
}

}  // namespace sommelier
}  // namespace vm_tools