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/lazy_instance.h"
+#include "base/macros.h"
+#include "base/observer_list.h"
+
+namespace exo {
+
+class NotificationSurface;
+
+// Keeps track of NotificationSurface.
+class NotificationSurfaceRegistry {

[reveman, 2016/06/16 03:35:20]

I'd like to avoid this class if possible. So far components/exo is not creating
a single global variable and it would be sad to see this change as part of this
change. Some options below:

1. If NotificationSurface class provided an aura::Window then we could just set
some unique notication property on the window and we get the same functionality
as this registry.

2. Have the NotificationSurface call into some notification manager API to
register itself.

[xiyuan, 2016/06/20 22:40:29]

Unfortunately, we cannot avoid this class. We can have an aura::Window for
NotificationSurface and use a property. I had a patch that does that. However,
looking at the your comment in notification_surface_registry.cc file that we
should fail when a client tried to create a NotificatoinSurface with bad id.
This would require to have something like this class so that we can validate the
request to create a NotificationSurface.

I have removed the LazyInstance part since that looks like the problematic part.
Now this registry is part of Display and NotificationSurface is created with a
pointer to the registry.

+ 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;
+  };
+
+  static NotificationSurfaceRegistry* Get();
+
+  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:
+  friend struct base::DefaultLazyInstanceTraits<NotificationSurfaceRegistry>;
+
+  NotificationSurfaceRegistry();
+  ~NotificationSurfaceRegistry();
+
+  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_