[GRC] Coordination Unit Graph Observer

services/resource_coordinator/coordination_unit/coordination_unit_impl.h

 // Copyright 2017 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 SERVICES_RESOURCE_COORDINATOR_COORDINATION_UNIT_COORDINATION_UNIT_IMPL_H_
 #define SERVICES_RESOURCE_COORDINATOR_COORDINATION_UNIT_COORDINATION_UNIT_IMPL_H_
 
 #include <list>
+#include <map>
 #include <memory>
 #include <set>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
+#include "base/callback.h"
 #include "base/optional.h"
 #include "base/values.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
+#include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
 #include "services/resource_coordinator/public/interfaces/coordination_unit.mojom.h"
 #include "services/resource_coordinator/public/interfaces/coordination_unit_provider.mojom.h"
 #include "services/service_manager/public/cpp/service_context_ref.h"
 
 namespace resource_coordinator {
 
+// Collection to manage CoordinationUnitEvent listeners.
+template <typename Listener, typename Filter>
+class CoordinationUnitEventListenerRegistry {
+ public:
+  CoordinationUnitEventListenerRegistry() = default;
+  ~CoordinationUnitEventListenerRegistry() = default;
+
+  // callbacks paired with this kNoFilter will always be invoked
+  static const Filter kNoFilter = static_cast<Filter>(0);
+
+  void AddListener(Listener listener, Filter filter) {
+    registry_[filter].push_back(listener);
+  }
+
+  void AddListener(Listener listener) { AddListener(listener, kNoFilter); }
+
+  // Get the listeners who are are either registered to be invoked for a
+  // specific filter or were registered with the kNoFilter.
+  // TODO(matthalp) add iterator support to replace this call and
+  // avoid excessive copying that currently occurs
+  std::vector<Listener> GetListeners(Filter filter) {
+    std::vector<Listener> listeners;
+
+    // Get listeners registered with a listener first.
+    AppendListeners(&listeners, filter);
+
+    // Get listeners registered without a filter after.
+    if (filter != kNoFilter) {
+      AppendListeners(&listeners, kNoFilter);
+    }
+
+    return listeners;
+  }
+
+  std::vector<Listener> GetListenersWithoutAFilter() {
+    return GetListeners(kNoFilter);
+  }
+
+ private:
+  // TODO(matthalp) Consider using a std::unordered_map instead.
+  std::map<Filter, std::vector<Listener>> registry_;

[ducbui, 2017/06/19 04:09:15]

Is there any reason for not using std::unordered_map in this version?

[matthalp, 2017/06/19 04:18:12]

std::unordered_map requires a std::hash implementation. C++11 does not support
std::hash for the enum classes that will be used as filter (but will be in
C++14). See "2148. Hashing enums should be supported directly by std::hash" in
http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148

The plan is to eventually use std::unordered_map, but I wanted to talk to zhenw
and oysteine to figure out the best way to proceed.

The easiest way is to pass in a hash via an struct-based operator(), which was
used inside of
services/resource_coordinator/public/cpp/coordination_unit_property_types.h for
https://codereview.chromium.org/2940983002.

Given how many places this is useful within services/resource_coordinator/ I
wanted to see if it made sense to have some sort of utils file to be included
where necessary.

+
+  void AppendListeners(std::vector<Listener>* listeners, Filter filter) {
+    listeners->insert(listeners->end(), registry_[filter].begin(),
+                      registry_[filter].end());
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(CoordinationUnitEventListenerRegistry);
+};
+
 class CoordinationUnitImpl : public mojom::CoordinationUnit {
+  typedef base::Callback<void(
+      const CoordinationUnitImpl* coordination_unit,
+      const CoordinationUnitImpl* child_coordination_unit)>
+      OnAddChildEventListener;
+  typedef base::Callback<void(
+      const CoordinationUnitImpl* coordination_unit,
+      const CoordinationUnitImpl* parent_coordination_unit)>
+      OnAddParentEventListener;
+  typedef base::Callback<void(
+      const CoordinationUnitImpl* coordination_unit,
+      const CoordinationUnitImpl* removed_child_coordination_unit)>
+      OnRemoveChildEventListener;
+  typedef base::Callback<void(
+      const CoordinationUnitImpl* coordination_unit,
+      const CoordinationUnitImpl* removed_parent_coordination_unit)>
+      OnRemoveParentEventListener;
+  typedef base::Callback<void(const CoordinationUnitImpl* coordination_unit,
+                              mojom::PropertyType property)>
+      OnPropertyChangedEventListener;
+  typedef base::Callback<void(const CoordinationUnitImpl* coordination_unit)>
+      OnWillBeDestroyedEventListener;
+
  public:
   CoordinationUnitImpl(
       const CoordinationUnitID& id,
       std::unique_ptr<service_manager::ServiceContextRef> service_ref);
   ~CoordinationUnitImpl() override;
 
   // Overridden from mojom::CoordinationUnit:
   void SendEvent(mojom::EventPtr event) override;
   void GetID(const GetIDCallback& callback) override;
   void AddBinding(mojom::CoordinationUnitRequest request) override;
@@ skipping 11 matching lines @@
     return property_store_;
   }
 
   static const double kCPUUsageMinimumForTesting;
   static const double kCPUUsageUnmeasuredForTesting;
   virtual double GetCPUUsageForTesting();
 
   // Clear property from internal key-value store
   void ClearProperty(mojom::PropertyType property);
   // Retrieve property from internal key-value store
-  base::Value GetProperty(mojom::PropertyType property);
+  base::Value GetProperty(mojom::PropertyType property) const;
   // Set property from internal key-value store
   void SetProperty(mojom::PropertyType property, base::Value value);
 
+  // Notify an instance it will be destroyed before its destructor is
+  // actually called.
+  void WillBeDestroyed();
+
+  CoordinationUnitEventListenerRegistry<OnAddChildEventListener,
+                                        CoordinationUnitType>&
+  on_add_child_event_listeners() {
+    return on_add_child_event_listeners_;
+  }
+  CoordinationUnitEventListenerRegistry<OnAddParentEventListener,
+                                        CoordinationUnitType>&
+  on_add_parent_event_listeners() {
+    return on_add_parent_event_listeners_;
+  }
+  CoordinationUnitEventListenerRegistry<OnRemoveChildEventListener,
+                                        CoordinationUnitType>&
+  on_remove_child_event_listeners() {
+    return on_remove_child_event_listeners_;
+  }
+  CoordinationUnitEventListenerRegistry<OnRemoveParentEventListener,
+                                        CoordinationUnitType>&
+  on_remove_parent_event_listeners() {
+    return on_remove_parent_event_listeners_;
+  }
+  CoordinationUnitEventListenerRegistry<OnPropertyChangedEventListener,
+                                        mojom::PropertyType>&
+  on_property_changed_event_listeners() {
+    return on_property_changed_event_listeners_;
+  }
+  CoordinationUnitEventListenerRegistry<OnWillBeDestroyedEventListener,
+                                        CoordinationUnitType>&
+  on_will_be_destroyed_event_listeners() {
+    return on_will_be_destroyed_event_listeners_;
+  }
+
  protected:
   const CoordinationUnitID id_;
   std::set<CoordinationUnitImpl*> children_;
   std::set<CoordinationUnitImpl*> parents_;
 
  private:
   bool AddChild(CoordinationUnitImpl* child);
   bool RemoveChild(CoordinationUnitImpl* child);
   void AddParent(CoordinationUnitImpl* parent);
   void RemoveParent(CoordinationUnitImpl* parent);
@@ skipping 15 matching lines @@
   bool SelfOrParentHasFlagSet(StateFlags state);
 
   std::unique_ptr<service_manager::ServiceContextRef> service_ref_;
   mojo::BindingSet<mojom::CoordinationUnit> bindings_;
 
   mojom::CoordinationPolicyCallbackPtr policy_callback_;
   mojom::CoordinationPolicyPtr current_policy_;
 
   base::Optional<bool> state_flags_[kNumStateFlags];
 
+  CoordinationUnitEventListenerRegistry<OnAddChildEventListener,
+                                        CoordinationUnitType>
+      on_add_child_event_listeners_;
+  CoordinationUnitEventListenerRegistry<OnAddParentEventListener,
+                                        CoordinationUnitType>
+      on_add_parent_event_listeners_;
+  CoordinationUnitEventListenerRegistry<OnRemoveChildEventListener,
+                                        CoordinationUnitType>
+      on_remove_child_event_listeners_;
+  CoordinationUnitEventListenerRegistry<OnRemoveParentEventListener,
+                                        CoordinationUnitType>
+      on_remove_parent_event_listeners_;
+  CoordinationUnitEventListenerRegistry<OnPropertyChangedEventListener,
+                                        mojom::PropertyType>
+      on_property_changed_event_listeners_;
+  // There is nothing to filter WillBeDestroyedEventCallbacks on so the
+  // CoordinationUnitType is used as a filter placeholder
+  CoordinationUnitEventListenerRegistry<OnWillBeDestroyedEventListener,
+                                        CoordinationUnitType>
+      on_will_be_destroyed_event_listeners_;
+
   DISALLOW_COPY_AND_ASSIGN(CoordinationUnitImpl);
 };
 
 }  // namespace resource_coordinator
 
 #endif  // SERVICES_RESOURCE_COORDINATOR_COORDINATION_UNIT_COORDINATION_UNIT_IMPL_H_