[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 : observers_) {
+      observer.OnChildAdded(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 : observers_) {
+      observer.OnChildRemoved(this, child);
+    }
+  }
+
+  return success;
 }
 
 void CoordinationUnitImpl::AddParent(CoordinationUnitImpl* parent) {
   DCHECK_EQ(0u, parents_.count(parent));
   parents_.insert(parent);
 
+  for (auto& observer : observers_) {
+    observer.OnParentAdded(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?
+  for (auto& observer : observers_) {
+    observer.OnParentRemoved(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 : observers_) {
+    observer.OnPropertyChanged(this, property);
+  }
+}
+
+void CoordinationUnitImpl::WillBeDestroyed() {
+  for (auto& observer : observers_) {
+    observer.OnCoordinationUnitWillBeDestroyed(this);
+  }
+}
+
+void CoordinationUnitImpl::AddObserver(
+    CoordinationUnitGraphObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void CoordinationUnitImpl::RemoveObserver(
+    CoordinationUnitGraphObserver* observer) {
+  observers_.RemoveObserver(observer);
 }
 
 }  // namespace resource_coordinator