[GRC] Coordination Unit Graph Observer

services/resource_coordinator/coordination_unit/coordination_unit_impl.cc

 // 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.
 
 #include "services/resource_coordinator/coordination_unit/coordination_unit_impl.h"
 
 #include <memory>
 #include <unordered_map>
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/resource_coordinator/coordination_unit/coordination_unit_graph_observer.h"
 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
 
 namespace resource_coordinator {
 
 namespace {
 
 using CUIDMap = std::unordered_map<CoordinationUnitID, CoordinationUnitImpl*>;
 
 CUIDMap& g_cu_map() {
   static CUIDMap* instance = new CUIDMap();
@@ skipping 127 matching lines @@
     if (AddChild(child)) {
       child->AddParent(this);
     }
   }
 }
 
 bool CoordinationUnitImpl::AddChild(CoordinationUnitImpl* child) {
   // We don't recalculate the policy here as policies are only dependent
   // on the current CU or its parents, not its children. In other words,
   // policies only bubble down.
-  return children_.count(child) ? false : children_.insert(child).second;
+  bool success =
+      children_.count(child) ? false : children_.insert(child).second;
+
+  if (success) {
+    for (auto* observer :
+         on_child_added_event_observer_registry_.GetObserversForFilter(
+             child->id().type)) {
+      observer->OnChildAddedEvent(this, child);
+    }
+  }
+
+  return success;
 }
 
 void CoordinationUnitImpl::RemoveChild(const CoordinationUnitID& child_id) {
   auto child_iter = g_cu_map().find(child_id);
   if (child_iter == g_cu_map().end()) {
     return;
   }
 
   CoordinationUnitImpl* child = child_iter->second;
   if (!HasChild(child)) {
     return;
   }
 
   DCHECK(child->id_ == child_id);
   DCHECK(child != this);
 
   if (RemoveChild(child)) {
     child->RemoveParent(this);
   }
 }
 
 bool CoordinationUnitImpl::RemoveChild(CoordinationUnitImpl* child) {
   size_t children_removed = children_.erase(child);
-  return children_removed > 0;
+  bool success = children_removed > 0;
+
+  if (success) {
+    for (auto* observer :
+         on_child_removed_event_observer_registry_.GetObserversForFilter(
+             child->id().type)) {
+      observer->OnChildRemovedEvent(this, child);
+    }
+  }
+
+  return success;
 }
 
 void CoordinationUnitImpl::AddParent(CoordinationUnitImpl* parent) {
   DCHECK_EQ(0u, parents_.count(parent));
   parents_.insert(parent);
 
+  for (auto* observer :
+       on_parent_added_event_observer_registry_.GetObserversForFilter(
+           parent->id().type)) {
+    observer->OnParentAddedEvent(this, parent);
+  }
+
   RecalcCoordinationPolicy();
 }
 
 void CoordinationUnitImpl::RemoveParent(CoordinationUnitImpl* parent) {
   size_t parents_removed = parents_.erase(parent);
   DCHECK_EQ(1u, parents_removed);
 
+  // TODO(matthalp, oysteine) should this go before or
+  // after RecalcCoordinationPolicy?

[Zhen Wang, 2017/06/19 22:54:25]

Is this undecided or you intend to ask Oystein for this CL?

[oystein (OOO til 10th of July), 2017/06/20 18:39:23]

Recalc should happen after, though TBH I think we'll end up refactoring the
whole RecalcCoordinationPolicy thing and replace it with observers, it's
essentially a hack of the same functionality (X event happens, triggering some
policy update on a callback).

[matthalp, 2017/06/20 19:02:52]

RecalcCoordinationPolicy does not do anything right now so it can be addressed
here or at a later point.

+oysteine

[matthalp, 2017/06/20 19:02:52]

Sounds good.

+  for (auto* observer :
+       on_parent_removed_event_observer_registry_.GetObserversForFilter(
+           parent->id().type)) {
+    observer->OnParentRemovedEvent(this, parent);
+  }
+
   RecalcCoordinationPolicy();
 }
 
 bool CoordinationUnitImpl::HasParent(CoordinationUnitImpl* unit) {
   for (CoordinationUnitImpl* parent : parents_) {
     if (parent == unit || parent->HasParent(unit)) {
       return true;
     }
   }
 
@@ skipping 23 matching lines @@
 
 void CoordinationUnitImpl::UnregisterCoordinationPolicyCallback() {
   policy_callback_.reset();
   current_policy_.reset();
 }
 
 double CoordinationUnitImpl::GetCPUUsageForTesting() {
   return kCPUUsageUnmeasuredForTesting;
 }
 
-base::Value CoordinationUnitImpl::GetProperty(mojom::PropertyType property) {
+base::Value CoordinationUnitImpl::GetProperty(
+    mojom::PropertyType property) const {
   auto value_it = property_store_.find(property);
 
   return value_it != property_store_.end() ? value_it->second : base::Value();
 }
 
 void CoordinationUnitImpl::ClearProperty(mojom::PropertyType property) {
   property_store_.erase(property);
 }
 
 void CoordinationUnitImpl::SetProperty(mojom::PropertyPtr property) {
   SetProperty(property->property, *property->value);
 }
 
 void CoordinationUnitImpl::SetProperty(mojom::PropertyType property,
                                        base::Value value) {
   // setting a property with an empty value is effectively clearing the
   // value from storage
   if (value.IsType(base::Value::Type::NONE)) {
     ClearProperty(property);
     return;
   }
 
   property_store_[property] = value;
+
+  for (auto* observer :
+       on_property_changed_event_observer_registry_.GetObserversForFilter(
+           property)) {
+    observer->OnPropertyChangedEvent(this, property);
+  }
+}
+
+void CoordinationUnitImpl::WillBeDestroyed() {
+  for (auto* observer : on_will_be_destroyed_event_observer_registry_
+                            .GetObserversWithoutAFilter()) {
+    observer->OnWillBeDestroyedEvent(this);
+  }
+}
+
+void CoordinationUnitImpl::ObserveOnChildAddedEvent(
+    CoordinationUnitGraphObserver* observer,
+    CoordinationUnitType child_filter) {
+  on_child_added_event_observer_registry_.AddObserver(observer, child_filter);
+}
+
+void CoordinationUnitImpl::ObserveOnChildAddedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  ObserveOnChildAddedEvent(
+      observer,
+      CoordinationUnitGraphObserverRegistry<CoordinationUnitType>::kNoFilter);
+}
+
+void CoordinationUnitImpl::ObserveOnParentAddedEvent(
+    CoordinationUnitGraphObserver* observer,
+    CoordinationUnitType parent_filter) {
+  on_parent_added_event_observer_registry_.AddObserver(observer, parent_filter);
+}
+
+void CoordinationUnitImpl::ObserveOnParentAddedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  ObserveOnParentAddedEvent(
+      observer,
+      CoordinationUnitGraphObserverRegistry<CoordinationUnitType>::kNoFilter);
+}
+
+void CoordinationUnitImpl::ObserveOnPropertyChangedEvent(
+    CoordinationUnitGraphObserver* observer,
+    mojom::PropertyType property_filter) {
+  on_property_changed_event_observer_registry_.AddObserver(observer,
+                                                           property_filter);
+}
+
+void CoordinationUnitImpl::ObserveOnPropertyChangedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  ObserveOnPropertyChangedEvent(
+      observer,
+      CoordinationUnitGraphObserverRegistry<mojom::PropertyType>::kNoFilter);
+}
+
+void CoordinationUnitImpl::ObserveOnChildRemovedEvent(
+    CoordinationUnitGraphObserver* observer,
+    CoordinationUnitType child_filter) {
+  on_child_removed_event_observer_registry_.AddObserver(observer, child_filter);
+}
+
+void CoordinationUnitImpl::ObserveOnChildRemovedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  ObserveOnChildRemovedEvent(
+      observer,
+      CoordinationUnitGraphObserverRegistry<CoordinationUnitType>::kNoFilter);
+}
+
+void CoordinationUnitImpl::ObserveOnParentRemovedEvent(
+    CoordinationUnitGraphObserver* observer,
+    CoordinationUnitType parent_filter) {
+  on_parent_removed_event_observer_registry_.AddObserver(observer,
+                                                         parent_filter);
+}
+
+void CoordinationUnitImpl::ObserveOnParentRemovedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  ObserveOnParentRemovedEvent(
+      observer,
+      CoordinationUnitGraphObserverRegistry<CoordinationUnitType>::kNoFilter);
+}
+
+void CoordinationUnitImpl::ObserveOnWillBeDestroyedEvent(
+    CoordinationUnitGraphObserver* observer) {
+  on_will_be_destroyed_event_observer_registry_.AddObserver(observer);
 }
 
 }  // namespace resource_coordinator