exo: Add initial support for service side decorations.

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 832 matching lines @@
   wl_resource* resource =
       wl_resource_create(client, &wl_subcompositor_interface, 1, id);
 
   wl_resource_set_implementation(resource, &subcompositor_implementation, data,
                                  nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_shell_surface_interface:
 
-class ShellSurfaceSizeObserver : public views::WidgetObserver {
- public:
-  ShellSurfaceSizeObserver(wl_resource* shell_surface_resource,
-                           const gfx::Size& initial_size)
-      : shell_surface_resource_(shell_surface_resource),
-        old_size_(initial_size) {
-    wl_shell_surface_send_configure(shell_surface_resource,
-                                    WL_SHELL_SURFACE_RESIZE_NONE,
-                                    old_size_.width(), old_size_.height());
-  }
-
-  // Overridden from view::WidgetObserver:
-  void OnWidgetDestroyed(views::Widget* widget) override { delete this; }
-  void OnWidgetBoundsChanged(views::Widget* widget,
-                             const gfx::Rect& new_bounds) override {
-    if (old_size_ == new_bounds.size())
-      return;
-
-    wl_shell_surface_send_configure(shell_surface_resource_,
-                                    WL_SHELL_SURFACE_RESIZE_NONE,
-                                    new_bounds.width(), new_bounds.height());
-    old_size_ = new_bounds.size();
-  }
-
- private:
-  wl_resource* shell_surface_resource_;
-  gfx::Size old_size_;
-
-  DISALLOW_COPY_AND_ASSIGN(ShellSurfaceSizeObserver);
-};
-
 void shell_surface_pong(wl_client* client,
                         wl_resource* resource,
                         uint32_t serial) {
   NOTIMPLEMENTED();
 }
 
 void shell_surface_move(wl_client* client,
                         wl_resource* resource,
                         wl_resource* seat_resource,
                         uint32_t serial) {
   GetUserDataAs<ShellSurface>(resource)->Move();
 }
 
 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)->SetEnabled(true);
+  ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
+  if (shell_surface->enabled())
+    return;
+
+  shell_surface->SetFrame(true);
+  shell_surface->SetRectangularShadow(true);
+  shell_surface->SetEnabled(true);
 }
 
 void shell_surface_set_transient(wl_client* client,
                                  wl_resource* resource,
                                  wl_resource* parent_resource,
                                  int x,
                                  int y,
                                  uint32_t flags) {
   ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
   if (shell_surface->enabled())
     return;
 
   // Parent widget can be found by locating the closest ancestor with a widget.
   views::Widget* parent_widget = nullptr;
   aura::Window* parent_window =
       GetUserDataAs<Surface>(parent_resource)->window();
   while (parent_window) {
     parent_widget = views::Widget::GetWidgetForNativeWindow(parent_window);
     if (parent_widget)
       break;
     parent_window = parent_window->parent();
   }
 
   gfx::Point origin(x, y);
+  ShellSurface* parent_shell_surface = nullptr;
 
   // Set parent if found and it is associated with a shell surface.
   if (parent_widget &&
       ShellSurface::GetMainSurface(parent_widget->GetNativeWindow())) {
     wm::ConvertPointToScreen(
         ShellSurface::GetMainSurface(parent_widget->GetNativeWindow())
             ->window(),
         &origin);
     // Shell surface widget delegate implementation of GetContentsView()
     // returns a pointer to the shell surface instance.
-    shell_surface->SetParent(static_cast<ShellSurface*>(
-        parent_widget->widget_delegate()->GetContentsView()));
+    parent_shell_surface = static_cast<ShellSurface*>(
+        parent_widget->widget_delegate()->GetContentsView());
   }
 
-  shell_surface->SetOrigin(origin);
-  shell_surface->SetActivatable(!(flags & WL_SHELL_SURFACE_TRANSIENT_INACTIVE));
+  if (flags & WL_SHELL_SURFACE_TRANSIENT_INACTIVE) {
+    shell_surface->SetOrigin(origin);
+    shell_surface->SetContainer(ash::kShellWindowId_SystemModalContainer);
+  } else {
+    shell_surface->SetFrame(true);
+    shell_surface->SetParent(parent_shell_surface);
+  }
+  shell_surface->SetRectangularShadow(true);
   shell_surface->SetEnabled(true);
 }
 
 void shell_surface_set_fullscreen(wl_client* client,
                                   wl_resource* resource,
                                   uint32_t method,
                                   uint32_t framerate,
                                   wl_resource* output_resource) {
   ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
   if (shell_surface->enabled())
     return;
 
   shell_surface->SetEnabled(true);
   shell_surface->SetFullscreen(true);
-
-  views::Widget* widget = shell_surface->GetWidget();
-  widget->AddObserver(new ShellSurfaceSizeObserver(
-      resource, widget->GetWindowBoundsInScreen().size()));
 }
 
 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) {
   ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
   if (shell_surface->enabled())
     return;
 
   shell_surface->SetEnabled(true);
   shell_surface->Maximize();
-
-  views::Widget* widget = shell_surface->GetWidget();
-  widget->AddObserver(new ShellSurfaceSizeObserver(
-      resource, widget->GetWindowBoundsInScreen().size()));
 }
 
 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 HandleShellSurfaceCloseCallback(wl_resource* resource) {
+  // Shell surface interface doesn't have a close event. Just send a ping event
+  // for now.
+  uint32_t serial = wl_display_next_serial(
+      wl_client_get_display(wl_resource_get_client(resource)));
+  wl_shell_surface_send_ping(resource, serial);
+  wl_client_flush(wl_resource_get_client(resource));
+}
+
+uint32_t HandleShellSurfaceConfigureCallback(
+    wl_resource* resource,
+    const gfx::Size& size,
+    ash::wm::WindowStateType state_type,
+    bool resizing,
+    bool activated) {
+  wl_shell_surface_send_configure(resource, WL_SHELL_SURFACE_RESIZE_NONE,
+                                  size.width(), size.height());
+  wl_client_flush(wl_resource_get_client(resource));
+  return 0;
+}
+
 void shell_get_shell_surface(wl_client* client,
                              wl_resource* resource,
                              uint32_t id,
                              wl_resource* surface) {
   std::unique_ptr<ShellSurface> shell_surface =
       GetUserDataAs<Display>(resource)->CreateShellSurface(
           GetUserDataAs<Surface>(surface));
   if (!shell_surface) {
     wl_resource_post_error(resource, WL_SHELL_ERROR_ROLE,
                            "surface has already been assigned a role");
     return;
   }
 
   wl_resource* shell_surface_resource =
       wl_resource_create(client, &wl_shell_surface_interface, 1, id);
 
   // Shell surfaces are initially disabled and needs to be explicitly mapped
   // before they are enabled and can become visible.
   shell_surface->SetEnabled(false);
 
+  shell_surface->set_close_callback(
+      base::Bind(&HandleShellSurfaceCloseCallback,
+                 base::Unretained(shell_surface_resource)));
+
+  shell_surface->set_configure_callback(
+      base::Bind(&HandleShellSurfaceConfigureCallback,
+                 base::Unretained(shell_surface_resource)));
+
   shell_surface->set_surface_destroyed_callback(base::Bind(
       &wl_resource_destroy, 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};
 
@@ skipping 445 matching lines @@
                               wl_fixed_t scale) {
   GetUserDataAs<ShellSurface>(resource)->SetScale(wl_fixed_to_double(scale));
 }
 
 void remote_surface_set_rectangular_shadow(wl_client* client,
                                            wl_resource* resource,
                                            int32_t x,
                                            int32_t y,
                                            int32_t width,
                                            int32_t height) {
-  GetUserDataAs<ShellSurface>(resource)->SetRectangularShadow(
-      gfx::Rect(x, y, width, height));
+  ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
+  gfx::Rect content_bounds(x, y, width, height);
+
+  shell_surface->SetRectangularShadowContentBounds(content_bounds);
+  shell_surface->SetRectangularShadow(!content_bounds.IsEmpty());
 }
 
 void remote_surface_set_rectangular_shadow_background_opacity(
     wl_client* client,
     wl_resource* resource,
     wl_fixed_t opacity) {
   GetUserDataAs<ShellSurface>(resource)->SetRectangularShadowBackgroundOpacity(
       wl_fixed_to_double(opacity));
 }
 
@@ skipping 1591 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