exo: Implement notification surface support

components/exo/notification_surface_registry.h

+// Copyright 2016 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.
+
+#ifndef COMPONENTS_EXO_NOTIFICATION_SURFACE_REGISTRY_H_
+#define COMPONENTS_EXO_NOTIFICATION_SURFACE_REGISTRY_H_
+
+#include <map>
+#include <string>
+
+#include "base/macros.h"
+#include "base/observer_list.h"
+
+namespace exo {
+
+class NotificationSurface;
+
+// Keeps track of NotificationSurface.
+class NotificationSurfaceRegistry {

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

There seems to be multiple levels of indirection here and I find it hard to
follow. Too many manager/registry classes maybe.

In src/ui/ there seems to be some manager/registry that already outlives the
lifetime of these notification surfaces. Can the class here just be an abstract
interface that is instead implemented by the manager class in
ui/arc/notification?

Basically, can we just reduce this to something like the
exo::NotificationSurfaceRegistry::Observer interface, maybe call it
exo::NotificationSurfaceManager and have exo::Display just call into that when
creating/destroying NotificationSurfaces? The benefit would be it avoid multiple
places where we manage these surfaces and reduce the code in exo/ which I think
should know as little as possible about how these notification surfaces are used
and managed. Does that make sense?

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

Okay. I moved this into ui/arc. However, I did not merge it into
ArcNotifiationManager because that is an ArcService and created after user
sign-in. It would be tricky to bind with exo::Display at that time point since
there is no global reference of either exo::Display or exo::wayland::Server.

I kept this code into a ArcNotificationSurfaceManager (more like rename of
NotificationSurfaceRegistry) and create and set into exo::Display on Wayland
init time.

+ public:
+  class Observer {
+   public:
+    // Invoked when a notification surface is added to the registry.
+    virtual void OnNotificationSurfaceAdded(NotificationSurface* surface) = 0;
+
+    // Invoked when a notification surface is removed from the registry.
+    virtual void OnNotificationSurfaceRemoved(NotificationSurface* surface) = 0;
+
+   protected:
+    virtual ~Observer() = default;
+  };
+
+  NotificationSurfaceRegistry();
+  ~NotificationSurfaceRegistry();
+
+  NotificationSurface* GetSurface(const std::string& notification_key) const;
+
+  void AddSurface(NotificationSurface* surface);
+  void RemoveSurface(NotificationSurface* surface);
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+ private:
+  using NotificationSurfaceMap =
+      std::map<std::string, exo::NotificationSurface*>;
+  NotificationSurfaceMap notification_surface_map_;
+
+  base::ObserverList<Observer> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotificationSurfaceRegistry);
+};
+
+}  // namespace exo
+
+#endif  // COMPONENTS_EXO_NOTIFICATION_SURFACE_REGISTRY_H_