exo: Initial support for multiple displays in ARC

components/exo/wayland/server.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/exo/wayland/server.h"
 
 #include <alpha-compositing-unstable-v1-server-protocol.h>
 #include <gaming-input-unstable-v1-server-protocol.h>
 #include <grp.h>
 #include <keyboard-configuration-unstable-v1-server-protocol.h>
@@ skipping 1965 matching lines @@
   shell_surface->SetRectangularSurfaceShadow(content_bounds);
 }
 
 void remote_surface_ack_configure(wl_client* client,
                                   wl_resource* resource,
                                   uint32_t serial) {
   GetUserDataAs<ShellSurface>(resource)->AcknowledgeConfigure(serial);
 }
 
 void remote_surface_move(wl_client* client, wl_resource* resource) {
-  NOTIMPLEMENTED();
+  GetUserDataAs<ShellSurface>(resource)->Move();
 }
 
 const struct zcr_remote_surface_v1_interface remote_surface_implementation = {
     remote_surface_destroy,
     remote_surface_set_app_id,
     remote_surface_set_window_geometry,
     remote_surface_set_scale,
     remote_surface_set_rectangular_shadow_DEPRECATED,
     remote_surface_set_rectangular_shadow_background_opacity,
     remote_surface_set_title,
@@ skipping 20 matching lines @@
 }
 
 const struct zcr_notification_surface_v1_interface
     notification_surface_implementation = {notification_surface_destroy};
 
 ////////////////////////////////////////////////////////////////////////////////
 // remote_shell_interface:
 
 // Implements remote shell interface and monitors workspace state needed
 // for the remote shell interface.
+//
+// This class is also responsible for conversion between server-side screen

[reveman, 2017/03/02 02:00:38]

I don't understand why we need to create another coordinate space for the
client. Why can't we just use chrome coordinates?

[Dominik Laskowski, 2017/03/03 13:50:41]

Because from the perspective of SF and DMS/WMS/AMS, there is a single display
and coordinates are relative to its top-left corner. Converting from that
coordinate space at the Wayland boundary is a simple solution that avoids
drastic non-upstreamable changes across the Android stack.

[reveman, 2017/03/06 19:02:13]

This is android specific so very confusing to see in Chromium code that is
supposed to be client agnostic. I'm not suggesting that we modify the Android
framework. I'm suggesting that we just modify the wayland code on the client
side that process these events instead of the code here that is not Android
specific.

[Dominik Laskowski, 2017/03/08 23:13:22]

But the server needs to know about the virtual display for synchronization, i.e.
to compensate when the screen position of the virtual origin changes.

+// coordinates and client-side virtual coordinates. This mapping enables
+// support for multiple displays when the client is limited to a single
+// display. In that case, the client uses a virtual display computed as
+// the bounding box of the physical displays, and the server translates
+// positions based on the display layout. For example, P is the client's
+// origin in virtual coordinates, and Q is the server's origin in screen
+// coordinates.
+//
+//  P        Q
+//  +-----+ /
+//  |     |/
+//  |  2  +-----------+
+//  |     |           |
+//  +-----+     1     |
+//        |           |
+//        +-----------+
+//
 class WaylandRemoteShell : public WMHelper::MaximizeModeObserver,
                            public WMHelper::ActivationObserver,
                            public display::DisplayObserver {
  public:
   WaylandRemoteShell(Display* display, wl_resource* remote_shell_resource)
       : display_(display),
         remote_shell_resource_(remote_shell_resource),
         weak_ptr_factory_(this) {
     auto* helper = WMHelper::GetInstance();
     helper->AddMaximizeModeObserver(this);
@@ skipping 13 matching lines @@
     helper->RemoveActivationObserver(this);
     display::Screen::GetScreen()->RemoveObserver(this);
   }
 
   bool IsMultiDisplaySupported() const {
     return wl_resource_get_version(remote_shell_resource_) >= 3;
   }
 
   std::unique_ptr<ShellSurface> CreateShellSurface(Surface* surface,
                                                    int container) {
-    return display_->CreateRemoteShellSurface(surface, gfx::Point(), container);
+    gfx::Point origin = ComputeVirtualDisplayBounds().origin();
+    std::unique_ptr<ShellSurface> shell_surface =
+        display_->CreateRemoteShellSurface(surface, origin, container);
+
+    if (IsMultiDisplaySupported()) {
+      shell_surface->set_display_config_changed_callback(base::Bind(
+          [](ShellSurface* shell_surface) {
+            shell_surface->SetOrigin(ComputeVirtualDisplayBounds().origin());
+          },
+          shell_surface.get()));
+    }
+
+    return shell_surface;
   }
 
   std::unique_ptr<NotificationSurface> CreateNotificationSurface(
       Surface* surface,
       const std::string& notification_id) {
     return display_->CreateNotificationSurface(surface, notification_id);
   }
 
   // Overridden from display::DisplayObserver:
+  void OnDisplayAdded(const display::Display& new_display) override {
+    if (IsMultiDisplaySupported())
+      ScheduleSendDisplayMetrics(0);
+  }
+
+  void OnDisplayRemoved(const display::Display& old_display) override {
+    if (IsMultiDisplaySupported())
+      ScheduleSendDisplayMetrics(0);
+  }
+
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t changed_metrics) override {
-    if (display::Screen::GetScreen()->GetPrimaryDisplay().id() != display.id())
+    if (!IsMultiDisplaySupported() &&
+        display::Screen::GetScreen()->GetPrimaryDisplay().id() != display.id())
       return;
 
     // No need to update when a primary display has changed without bounds
     // change. See WaylandPrimaryDisplayObserver::OnDisplayMetricsChanged
     // for more details.
     if (changed_metrics &
         (DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_DEVICE_SCALE_FACTOR |
          DISPLAY_METRIC_ROTATION | DISPLAY_METRIC_WORK_AREA)) {
       ScheduleSendDisplayMetrics(0);
     }
@@ skipping 23 matching lines @@
         FROM_HERE, base::Bind(&WaylandRemoteShell::SendDisplayMetrics,
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(delay_ms));
   }
 
   void SendDisplayMetrics() {
     if (!needs_send_display_metrics_)
       return;
     needs_send_display_metrics_ = false;
 
-    const display::Screen* screen = display::Screen::GetScreen();
-    const display::Display primary_display = screen->GetPrimaryDisplay();
+    display::Display primary_display =
+        display::Screen::GetScreen()->GetPrimaryDisplay();
 
+    gfx::Size display_size = IsMultiDisplaySupported()
+                                 ? ComputeVirtualDisplayBounds().size()
+                                 : primary_display.size();
+
+    // TODO(domlaskowski): Send insets for each workspace.
     const gfx::Insets& work_area_insets = primary_display.GetWorkAreaInsets();
 
     zcr_remote_shell_v1_send_configuration_changed(
-        remote_shell_resource_,
-        primary_display.size().width(),
-        primary_display.size().height(),
+        remote_shell_resource_, display_size.width(), display_size.height(),
         OutputTransform(primary_display.rotation()),
         wl_fixed_from_double(primary_display.device_scale_factor()),
         work_area_insets.left(), work_area_insets.top(),
         work_area_insets.right(), work_area_insets.bottom(), layout_mode_);
     wl_client_flush(wl_resource_get_client(remote_shell_resource_));
   }
 
   void SendActivated(aura::Window* gained_active, aura::Window* lost_active) {
     Surface* gained_active_surface =
         gained_active ? ShellSurface::GetMainSurface(gained_active) : nullptr;
@@ skipping 20 matching lines @@
         wl_resource_get_client(lost_active_surface_resource) != client) {
       lost_active_surface_resource = nullptr;
     }
 
     zcr_remote_shell_v1_send_activated(remote_shell_resource_,
                                        gained_active_surface_resource,
                                        lost_active_surface_resource);
     wl_client_flush(client);
   }
 
+  static gfx::Rect ComputeVirtualDisplayBounds() {
+    // Virtual screen is the bounding box of the displays in screen coordinates.
+    gfx::Rect bounds;
+    for (const auto& display : display::Screen::GetScreen()->GetAllDisplays())
+      bounds.Union(display.bounds());
+    return bounds;
+  }
+
   // The exo display instance. Not owned.
   Display* const display_;
 
   // The remote shell resource associated with observer.
   wl_resource* const remote_shell_resource_;
 
   bool needs_send_display_metrics_ = true;
 
   int layout_mode_ = ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_WINDOWED;
 
@@ skipping 132 matching lines @@
                          wl_resource_get_version(resource), id);
   SetImplementation(notification_surface_resource,
                     &notification_surface_implementation,
                     std::move(notification_surface));
 }
 
 const struct zcr_remote_shell_v1_interface remote_shell_implementation = {
     remote_shell_destroy, remote_shell_get_remote_surface,
     remote_shell_get_notification_surface};
 
-const uint32_t remote_shell_version = 2;
+const uint32_t remote_shell_version = 3;
 
 void bind_remote_shell(wl_client* client,
                        void* data,
                        uint32_t version,
                        uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zcr_remote_shell_v1_interface,
                          std::min(version, remote_shell_version), id);
 
   SetImplementation(resource, &remote_shell_implementation,
@@ skipping 1436 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo