exo: Implement notification surface support

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 24 matching lines @@
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
 #include "components/exo/keyboard.h"
 #include "components/exo/keyboard_delegate.h"
+#include "components/exo/notification_surface.h"
+#include "components/exo/notification_surface_registry.h"
 #include "components/exo/pointer.h"
 #include "components/exo/pointer_delegate.h"
 #include "components/exo/shared_memory.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
 #include "components/exo/surface_property.h"
 #include "components/exo/touch.h"
 #include "components/exo/touch_delegate.h"
 #include "ipc/unix_domain_socket_util.h"
@@ skipping 1423 matching lines @@
     remote_surface_set_scale,
     remote_surface_fullscreen,
     remote_surface_maximize,
     remote_surface_minimize,
     remote_surface_restore,
     remote_surface_pin,
     remote_surface_unpin,
     remote_surface_unfullscreen};
 
 ////////////////////////////////////////////////////////////////////////////////
+// notification_surface_interface:
+
+void notification_surface_destroy(wl_client* client, wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+const struct zwp_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.
 class WaylandRemoteShell : public ash::ShellObserver,
                            public aura::client::ActivationChangeObserver,
                            public display::DisplayObserver {
  public:
   WaylandRemoteShell(Display* display,
                      int64_t display_id,
@@ skipping 12 matching lines @@
     ash::WmShell::Get()->RemoveShellObserver(this);
     ash::Shell::GetInstance()->activation_client()->RemoveObserver(this);
     display::Screen::GetScreen()->RemoveObserver(this);
   }
 
   std::unique_ptr<ShellSurface> CreateShellSurface(Surface* surface,
                                                    int container) {
     return display_->CreateRemoteShellSurface(surface, container);
   }
 
+  bool IsValidNotificationId(const std::string& notification_id) const {

[reveman, 2016/06/22 16:44:30]

Would be nice if this could instead be validated when inserting the surface so
we can avoid two lookups. Maybe just have a null return value from
CreateNotificationSurface mean generate this error. I think that should work
after changing how ERROR_ROLE messages are generated as suggested below.

[xiyuan, 2016/06/23 14:46:43]

Done.

+    return display_->notification_surface_registry()->GetSurface(
+               notification_id) == nullptr;
+  }
+
+  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 {}
   void OnDisplayRemoved(const display::Display& new_display) override {}
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t metrics) override {
     if (display.id() == display_id_)
       SendConfigure();
   }
 
   // Overridden from ash::ShellObserver:
@@ skipping 155 matching lines @@
       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));
 }
 
+void remote_shell_get_notification_surface(wl_client* client,
+                                           wl_resource* resource,
+                                           uint32_t id,
+                                           wl_resource* surface,
+                                           const char* notification_id) {
+  WaylandRemoteShell* remote_shell =
+      GetUserDataAs<WaylandRemoteShell>(resource);
+  if (!remote_shell->IsValidNotificationId(notification_id)) {
+    wl_resource_post_error(resource,
+                           ZWP_REMOTE_SHELL_V1_ERROR_INVALID_NOTIFICATION_ID,
+                           "invalid notification id");
+    return;
+  }
+
+  std::unique_ptr<NotificationSurface> notification_surface =
+      remote_shell->CreateNotificationSurface(GetUserDataAs<Surface>(surface),
+                                              std::string(notification_id));
+  if (!notification_surface) {

[reveman, 2016/06/22 16:44:31]

Instead of using a null return value here. Can you check this earlier by calling
Surface::HasSurfaceDelegate()?

[xiyuan, 2016/06/23 14:46:43]

Done.

+    wl_resource_post_error(resource, ZWP_REMOTE_SHELL_V1_ERROR_ROLE,
+                           "surface has already been assigned a role");
+    return;
+  }
+
+  wl_resource* notification_surface_resource =
+      wl_resource_create(client, &zwp_notification_surface_v1_interface,
+                         wl_resource_get_version(resource), id);
+  SetImplementation(notification_surface_resource,
+                    &notification_surface_implementation,
+                    std::move(notification_surface));
+}
+
 const struct zwp_remote_shell_v1_interface remote_shell_implementation = {
-    remote_shell_destroy, remote_shell_get_remote_surface};
+    remote_shell_destroy, remote_shell_get_remote_surface,
+    remote_shell_get_notification_surface};
 
-const uint32_t remote_shell_version = 3;
+const uint32_t remote_shell_version = 4;
 
 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,
                          std::min(version, remote_shell_version), id);
 
   // TODO(reveman): Multi-display support.
@@ skipping 1030 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