MC: WIP: dispatching notifications from browser to renderer

components/memory_coordinator/browser/memory_coordinator.cc

Index: components/memory_coordinator/browser/memory_coordinator.cc
diff --git a/components/memory_coordinator/browser/memory_coordinator.cc b/components/memory_coordinator/browser/memory_coordinator.cc
index fab8c98c67b30ce97ba77dae00c677af5b43f586..eab59b3c47304d70cafea6e7c2be631714c409f3 100644
--- a/components/memory_coordinator/browser/memory_coordinator.cc
+++ b/components/memory_coordinator/browser/memory_coordinator.cc
@@ -6,6 +6,29 @@
 
 namespace memory_coordinator {
 
+namespace {
+
+MemoryCoordinator* g_coordinator = nullptr;
+
+// TODO(bashi): This should be a tentative translation.
+mojom::MemoryState ConvertPressureLevelToMemoryState(
+    base::MemoryPressureMonitor::MemoryPressureLevel level) {
+  switch (level) {
+    case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
+      return mojom::MemoryState::UNKNOWN;
+    case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
+      return mojom::MemoryState::THROTTLED;
+    case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
+      return mojom::MemoryState::SUSPENDED;
+    default:
+      break;
+  }
+  NOTREACHED();
+  return mojom::MemoryState::UNKNOWN;
+}
+
+}
+
 // The implementation of MemoryCoordinatorHandle. See memory_coordinator.mojom
 // for the role of this class.
 class MemoryCoordinatorHandleImpl : public mojom::MemoryCoordinatorHandle {
@@ -31,12 +54,26 @@ class MemoryCoordinatorHandleImpl : public mojom::MemoryCoordinatorHandle {
   DISALLOW_COPY_AND_ASSIGN(MemoryCoordinatorHandleImpl);
 };
 
+// static
+MemoryCoordinator* MemoryCoordinator::GetInstance() {
+  return g_coordinator;
+}
+
 MemoryCoordinator::MemoryCoordinator()
     : pressure_level_dispatcher_(
           base::Bind(&MemoryCoordinator::OnMemoryPressure,
-                     base::Unretained(this))) {}
+                     base::Unretained(this))),
+      children_dispatch_callback_(
+          base::Bind(&MemoryCoordinator::DispatchMemoryPressureToChildren,
+                     base::Unretained(this))) {
+  DCHECK(!g_coordinator);
+  g_coordinator = this;
+}
 
-MemoryCoordinator::~MemoryCoordinator() {}
+MemoryCoordinator::~MemoryCoordinator() {
+  DCHECK(g_coordinator);
+  g_coordinator = nullptr;
+}
 
 void MemoryCoordinator::CreateHandle(
     int render_process_id,
@@ -48,6 +85,21 @@ void MemoryCoordinator::CreateHandle(
   children_[render_process_id].reset(handle);
 }
 
+void MemoryCoordinator::SetChildrenDispatchCallback(
+    const DispatchCallback& callback) {
+  children_dispatch_callback_ = callback;
+}
+
+void MemoryCoordinator::DispatchToRenderer(
+    int render_process_id,
+    base::MemoryPressureMonitor::MemoryPressureLevel level) {
+  const auto& it = children_.find(render_process_id);
+  if (it == children_.end()) {
+    return;
+  }
+  it->second->child()->OnStateChange(ConvertPressureLevelToMemoryState(level));
+}
+
 size_t MemoryCoordinator::NumChildrenForTesting() {
   return children_.size();
 }
@@ -61,13 +113,18 @@ void MemoryCoordinator::OnMemoryPressure(
   // TODO(bashi): The current implementation just translates memory pressure
   // levels to memory coordinator states. The logic will be replaced with
   // the priority tracker.
-  if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE) {
-    clients()->Notify(FROM_HERE, &MemoryCoordinatorClient::OnMemoryStateChange,
-                      mojom::MemoryState::THROTTLED);
-  } else if (level ==
-             base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
-    clients()->Notify(FROM_HERE, &MemoryCoordinatorClient::OnMemoryStateChange,
-                      mojom::MemoryState::SUSPENDED);
+  auto state = ConvertPressureLevelToMemoryState(level);
+  clients()->Notify(FROM_HERE, &MemoryCoordinatorClient::OnMemoryStateChange,
+                    state);
+
+  children_dispatch_callback_.Run(level);
+}
+
+void MemoryCoordinator::DispatchMemoryPressureToChildren(
+    base::MemoryPressureMonitor::MemoryPressureLevel level) {
+  auto state = ConvertPressureLevelToMemoryState(level);
+  for (auto& pair : children_) {
+    pair.second->child()->OnStateChange(state);
   }
 }