exo: Implement version 2 of remote shell interface.

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 <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 1154 matching lines @@
                                 wl_resource* resource,
                                 wl_resource* output) {
   GetUserDataAs<ShellSurface>(resource)->SetFullscreen(true);
 }
 
 void xdg_surface_unset_fullscreen(wl_client* client, wl_resource* resource) {
   GetUserDataAs<ShellSurface>(resource)->SetFullscreen(false);
 }
 
 void xdg_surface_set_minimized(wl_client* client, wl_resource* resource) {
-  NOTIMPLEMENTED();
+  GetUserDataAs<ShellSurface>(resource)->Minimize();
 }
 
 const struct xdg_surface_interface xdg_surface_implementation = {
     xdg_surface_destroy,
     xdg_surface_set_parent,
     xdg_surface_set_title,
     xdg_surface_set_add_id,
     xdg_surface_show_window_menu,
     xdg_surface_move,
     xdg_surface_resize,
@@ skipping 198 matching lines @@
   GetUserDataAs<ShellSurface>(resource)->SetGeometry(
       gfx::Rect(x, y, width, height));
 }
 
 void remote_surface_set_scale(wl_client* client,
                               wl_resource* resource,
                               wl_fixed_t scale) {
   GetUserDataAs<ShellSurface>(resource)->SetScale(wl_fixed_to_double(scale));
 }
 
+void remote_surface_fullscreen(wl_client* client, wl_resource* resource) {

[Daniele Castagna, 2016/06/06 03:11:23]

This file could be probably made much compact with a little bit of
metaprogramming.

[reveman, 2016/06/06 03:26:57]

Yes, that was always the plan but it's been easier to just copy-paste for now.
If you have some good suggestions for how to eliminate some of this boiler plate
code than let's discuss that and try to get it done.

+  GetUserDataAs<ShellSurface>(resource)->SetFullscreen(true);
+}
+
+void remote_surface_maximize(wl_client* client, wl_resource* resource) {
+  GetUserDataAs<ShellSurface>(resource)->Maximize();
+}
+
+void remote_surface_minimize(wl_client* client, wl_resource* resource) {
+  GetUserDataAs<ShellSurface>(resource)->Minimize();
+}
+
+void remote_surface_restore(wl_client* client, wl_resource* resource) {
+  GetUserDataAs<ShellSurface>(resource)->Restore();
+}
+
 const struct zwp_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_destroy,
+    remote_surface_set_app_id,
+    remote_surface_set_window_geometry,
+    remote_surface_set_scale,
+    remote_surface_fullscreen,
+    remote_surface_maximize,
+    remote_surface_minimize,
+    remote_surface_restore};
 
 ////////////////////////////////////////////////////////////////////////////////
 // remote_shell_interface:
 
 // Observer class that monitors workspace state needed to implement the
 // remote shell interface.
 class WaylandWorkspaceObserver : public ash::ShellObserver,
                                  public aura::client::ActivationChangeObserver,
                                  public display::DisplayObserver {
  public:
@@ skipping 107 matching lines @@
       DLOG(WARNING) << "Unsupported container: " << container;
       return ash::kShellWindowId_DefaultContainer;
   }
 }
 
 void HandleRemoteSurfaceCloseCallback(wl_resource* resource) {
   zwp_remote_surface_v1_send_close(resource);
   wl_client_flush(wl_resource_get_client(resource));
 }
 
+void HandleRemoteSurfaceStateChangedCallback(
+    wl_resource* resource,
+    ash::wm::WindowStateType old_state_type,
+    ash::wm::WindowStateType new_state_type) {
+  DCHECK_NE(old_state_type, new_state_type);
+
+  switch (old_state_type) {
+    case ash::wm::WINDOW_STATE_TYPE_MINIMIZED:
+      if (wl_resource_get_version(resource) >= 2)

[Daniele Castagna, 2016/06/06 03:11:23]

Wouldn't this code be clearer if it was something like

if (wl_resource_get_version(resource) >= 2) {
  switch(old_state) {
  }
  switch(new_state) {
  }
} else [
  bla bla
}

Also, would there ever be a reason why you might not want to unset and set a
state if it ends up in the same state?

[reveman, 2016/06/06 03:26:57]

I'm expecting "wl_resource_get_version(resource) >= 3" in the future so I think
the current code will be easier to ready for that reason.
Maybe but I have the DCHECK above that assumes this will never be called in that
way. And that is the case for chrome today afaict.

+        zwp_remote_surface_v1_send_unset_minimized(resource);
+      break;
+    case ash::wm::WINDOW_STATE_TYPE_MAXIMIZED:
+      if (wl_resource_get_version(resource) >= 2)
+        zwp_remote_surface_v1_send_unset_maximized(resource);
+      break;
+    case ash::wm::WINDOW_STATE_TYPE_FULLSCREEN:
+      zwp_remote_surface_v1_send_unset_fullscreen(resource);
+      break;
+    default:
+      break;
+  }
+  switch (new_state_type) {
+    case ash::wm::WINDOW_STATE_TYPE_MINIMIZED:
+      if (wl_resource_get_version(resource) >= 2)
+        zwp_remote_surface_v1_send_set_minimized(resource);
+      break;
+    case ash::wm::WINDOW_STATE_TYPE_MAXIMIZED:
+      if (wl_resource_get_version(resource) >= 2)
+        zwp_remote_surface_v1_send_set_maximized(resource);
+      break;
+    case ash::wm::WINDOW_STATE_TYPE_FULLSCREEN:
+      zwp_remote_surface_v1_send_set_fullscreen(resource);
+      break;
+    default:
+      break;
+  }
+  wl_client_flush(wl_resource_get_client(resource));
+}
+
 void remote_shell_get_remote_surface(wl_client* client,
                                      wl_resource* resource,
                                      uint32_t id,
                                      wl_resource* surface,
                                      uint32_t container) {
   std::unique_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)->CreateRemoteShellSurface(
           GetUserDataAs<Surface>(surface), RemoteSurfaceContainer(container));
   if (!shell_surface) {
     wl_resource_post_error(resource, ZWP_REMOTE_SHELL_V1_ERROR_ROLE,
                            "surface has already been assigned a role");
     return;
   }
 
   wl_resource* remote_surface_resource =
-      wl_resource_create(client, &zwp_remote_surface_v1_interface, 1, id);
+      wl_resource_create(client, &zwp_remote_surface_v1_interface,
+                         wl_resource_get_version(resource), id);
 
   shell_surface->set_close_callback(
       base::Bind(&HandleRemoteSurfaceCloseCallback,
                  base::Unretained(remote_surface_resource)));
+  shell_surface->set_state_changed_callback(
+      base::Bind(&HandleRemoteSurfaceStateChangedCallback,
+                 base::Unretained(remote_surface_resource)));
 
   SetImplementation(remote_surface_resource, &remote_surface_implementation,
                     std::move(shell_surface));
 }
 
 const struct zwp_remote_shell_v1_interface remote_shell_implementation = {
     remote_shell_destroy, remote_shell_get_remote_surface};
 
+const uint32_t remote_shell_version = 2;
+
 void bind_remote_shell(wl_client* client,
                        void* data,
                        uint32_t version,
                        uint32_t id) {
   wl_resource* resource =
-      wl_resource_create(client, &zwp_remote_shell_v1_interface, 1, id);
+      wl_resource_create(client, &zwp_remote_shell_v1_interface,
+                         std::min(version, remote_shell_version), id);
 
   // TODO(reveman): Multi-display support.
   const display::Display& display = ash::Shell::GetInstance()
                                         ->display_manager()
                                         ->GetPrimaryDisplayCandidate();
 
   SetImplementation(
       resource, &remote_shell_implementation,
       base::WrapUnique(new WaylandWorkspaceObserver(display, resource)));
 }
@@ skipping 859 matching lines @@
   wl_global_create(wl_display_.get(), &wl_data_device_manager_interface, 1,
                    display_, bind_data_device_manager);
   wl_global_create(wl_display_.get(), &wl_seat_interface, seat_version,
                    display_, bind_seat);
   wl_global_create(wl_display_.get(), &wp_viewporter_interface, 1, display_,
                    bind_viewporter);
   wl_global_create(wl_display_.get(), &zwp_secure_output_v1_interface, 1,
                    display_, bind_secure_output);
   wl_global_create(wl_display_.get(), &zwp_alpha_compositing_v1_interface, 1,
                    display_, bind_alpha_compositing);
-  wl_global_create(wl_display_.get(), &zwp_remote_shell_v1_interface, 1,
-                   display_, bind_remote_shell);
+  wl_global_create(wl_display_.get(), &zwp_remote_shell_v1_interface,
+                   remote_shell_version, display_, bind_remote_shell);
 }
 
 Server::~Server() {}
 
 // static
 std::unique_ptr<Server> Server::Create(Display* display) {
   std::unique_ptr<Server> server(new Server(display));
 
   char* runtime_dir = getenv("XDG_RUNTIME_DIR");
   if (!runtime_dir) {
@@ skipping 51 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