exo: Improve Maximize and Fullscreen support for ShellSurfaces.

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 <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <wayland-server-core.h>
@@ skipping 102 matching lines @@
 
 void surface_damage(wl_client* client,
                     wl_resource* resource,
                     int32_t x,
                     int32_t y,
                     int32_t width,
                     int32_t height) {
   GetUserDataAs<Surface>(resource)->Damage(gfx::Rect(x, y, width, height));
 }
 
-void handle_surface_frame_callback(wl_resource* resource,
-                                   base::TimeTicks frame_time) {
+void HandleSurfaceFrameCallback(wl_resource* resource,
+                                base::TimeTicks frame_time) {
   if (!frame_time.is_null()) {
     wl_callback_send_done(resource,
                           (frame_time - base::TimeTicks()).InMilliseconds());
     // TODO(reveman): Remove this potentially blocking flush and instead watch
     // the file descriptor to be ready for write without blocking.
     wl_client_flush(wl_resource_get_client(resource));
   }
   wl_resource_destroy(resource);
 }
 
 void surface_frame(wl_client* client,
                    wl_resource* resource,
                    uint32_t callback) {
   wl_resource* callback_resource =
       wl_resource_create(client, &wl_callback_interface, 1, callback);
   if (!callback_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   // base::Unretained is safe as the resource owns the callback.
   scoped_ptr<base::CancelableCallback<void(base::TimeTicks)>>
-  cancelable_callback(new base::CancelableCallback<void(base::TimeTicks)>(
-      base::Bind(&handle_surface_frame_callback,
-                 base::Unretained(callback_resource))));
+  cancelable_callback(
+      new base::CancelableCallback<void(base::TimeTicks)>(base::Bind(
+          &HandleSurfaceFrameCallback, base::Unretained(callback_resource))));
 
   GetUserDataAs<Surface>(resource)
       ->RequestFrameCallback(cancelable_callback->callback());
 
   SetImplementation(callback_resource, nullptr, std::move(cancelable_callback));
 }
 
 void surface_set_opaque_region(wl_client* client,
                                wl_resource* resource,
                                wl_resource* region_resource) {
@@ skipping 471 matching lines @@
 
 void shell_surface_resize(wl_client* client,
                           wl_resource* resource,
                           wl_resource* seat_resource,
                           uint32_t serial,
                           uint32_t edges) {
   NOTIMPLEMENTED();
 }
 
 void shell_surface_set_toplevel(wl_client* client, wl_resource* resource) {
-  GetUserDataAs<ShellSurface>(resource)->SetToplevel();
+  GetUserDataAs<ShellSurface>(resource)->Init();
 }
 
 void shell_surface_set_transient(wl_client* client,
                                  wl_resource* resource,
                                  wl_resource* parent_resource,
                                  int x,
                                  int y,
                                  uint32_t flags) {
   NOTIMPLEMENTED();
 }
 
 void shell_surface_set_fullscreen(wl_client* client,
                                   wl_resource* resource,
                                   uint32_t method,
                                   uint32_t framerate,
                                   wl_resource* output_resource) {
-  GetUserDataAs<ShellSurface>(resource)->SetFullscreen();
+  GetUserDataAs<ShellSurface>(resource)->Init();
+  GetUserDataAs<ShellSurface>(resource)->SetFullscreen(true);
 }
 
 void shell_surface_set_popup(wl_client* client,
                              wl_resource* resource,
                              wl_resource* seat_resource,
                              uint32_t serial,
                              wl_resource* parent_resource,
                              int32_t x,
                              int32_t y,
                              uint32_t flags) {
   NOTIMPLEMENTED();
 }
 
 void shell_surface_set_maximized(wl_client* client,
                                  wl_resource* resource,
                                  wl_resource* output_resource) {
-  GetUserDataAs<ShellSurface>(resource)->SetMaximized();
+  GetUserDataAs<ShellSurface>(resource)->Init();
+  GetUserDataAs<ShellSurface>(resource)->Maximize();
 }
 
 void shell_surface_set_title(wl_client* client,
                              wl_resource* resource,
                              const char* title) {
   GetUserDataAs<ShellSurface>(resource)
       ->SetTitle(base::string16(base::UTF8ToUTF16(title)));
 }
 
 void shell_surface_set_class(wl_client* client,
                              wl_resource* resource,
                              const char* clazz) {
   GetUserDataAs<ShellSurface>(resource)->SetApplicationId(clazz);
 }
 
 const struct wl_shell_surface_interface shell_surface_implementation = {
     shell_surface_pong,          shell_surface_move,
     shell_surface_resize,        shell_surface_set_toplevel,
     shell_surface_set_transient, shell_surface_set_fullscreen,
     shell_surface_set_popup,     shell_surface_set_maximized,
     shell_surface_set_title,     shell_surface_set_class};
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_shell_interface:
 
+void HandleShellSurfaceConfigureCallback(wl_resource* resource,
+                                         const gfx::Size& size) {
+  wl_shell_surface_send_configure(resource, WL_SHELL_SURFACE_RESIZE_NONE,
+                                  size.width(), size.height());
+}
+
 void shell_get_shell_surface(wl_client* client,
                              wl_resource* resource,
                              uint32_t id,
                              wl_resource* surface) {
   scoped_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)
           ->CreateShellSurface(GetUserDataAs<Surface>(surface));
   if (!shell_surface) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* shell_surface_resource =
       wl_resource_create(client, &wl_shell_surface_interface, 1, id);
   if (!shell_surface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   shell_surface->set_surface_destroyed_callback(base::Bind(
       &wl_resource_destroy, base::Unretained(shell_surface_resource)));
 
+  shell_surface->set_configure_callback(
+      base::Bind(&HandleShellSurfaceConfigureCallback,
+                 base::Unretained(shell_surface_resource)));
+
   SetImplementation(shell_surface_resource, &shell_surface_implementation,
                     std::move(shell_surface));
 }
 
 const struct wl_shell_interface shell_implementation = {
     shell_get_shell_surface};
 
 void bind_shell(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_shell_interface, 1, id);
@@ skipping 114 matching lines @@
                                      wl_resource* resource,
                                      int32_t x,
                                      int32_t y,
                                      int32_t width,
                                      int32_t height) {
   GetUserDataAs<ShellSurface>(resource)
       ->SetGeometry(gfx::Rect(x, y, width, height));
 }
 
 void xdg_surface_set_maximized(wl_client* client, wl_resource* resource) {
-  NOTIMPLEMENTED();
+  GetUserDataAs<ShellSurface>(resource)->Maximize();
 }
 
 void xdg_surface_unset_maximized(wl_client* client, wl_resource* resource) {
   NOTIMPLEMENTED();
 }
 
 void xdg_surface_set_fullscreen(wl_client* client,
                                 wl_resource* resource,
                                 wl_resource* output) {
-  NOTIMPLEMENTED();
+  GetUserDataAs<ShellSurface>(resource)->SetFullscreen(true);
 }
 
 void xdg_surface_unset_fullscreen(wl_client* client, wl_resource* resource) {
-  NOTIMPLEMENTED();
+  GetUserDataAs<ShellSurface>(resource)->SetFullscreen(false);
 }
 
 void xdg_surface_set_minimized(wl_client* client, wl_resource* resource) {
   NOTIMPLEMENTED();
 }
 
 const struct xdg_surface_interface xdg_surface_implementation = {
     xdg_surface_destroy,
     xdg_surface_set_parent,
     xdg_surface_set_title,
@@ skipping 23 matching lines @@
 
 void xdg_shell_use_unstable_version(wl_client* client,
                                     wl_resource* resource,
                                     int32_t version) {
   if (version > XDG_SHELL_VERSION) {
     wl_resource_post_error(resource, 1,
                            "xdg-shell version not implemented yet.");
   }
 }
 
+void HandleXdgSurfaceConfigureCallback(wl_resource* resource,
+                                       const gfx::Size& size) {
+  // TODO(reveman): Include the shell surface state (maximized, active, etc.)
+  // and make sure this configure callback is called when any of that state
+  // changes.
+  wl_array states;
+  wl_array_init(&states);
+  xdg_surface_send_configure(resource, size.width(), size.height(), &states,
+                             wl_display_next_serial(wl_client_get_display(
+                                 wl_resource_get_client(resource))));
+}
+
 void xdg_shell_get_xdg_surface(wl_client* client,
                                wl_resource* resource,
                                uint32_t id,
                                wl_resource* surface) {
   scoped_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)
           ->CreateShellSurface(GetUserDataAs<Surface>(surface));
   if (!shell_surface) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* xdg_surface_resource =
       wl_resource_create(client, &xdg_surface_interface, 1, id);
   if (!xdg_surface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   // An XdgSurface is a toplevel shell surface.
-  shell_surface->SetToplevel();
+  shell_surface->Init();
 
   shell_surface->set_close_callback(base::Bind(
       &xdg_surface_send_close, base::Unretained(xdg_surface_resource)));
 
+  shell_surface->set_configure_callback(
+      base::Bind(&HandleXdgSurfaceConfigureCallback,
+                 base::Unretained(xdg_surface_resource)));
+
   SetImplementation(xdg_surface_resource, &xdg_surface_implementation,
                     std::move(shell_surface));
 }
 
 void xdg_shell_get_xdg_popup(wl_client* client,
                              wl_resource* resource,
                              uint32_t id,
                              wl_resource* surface,
                              wl_resource* parent,
                              wl_resource* seat,
@@ skipping 564 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