MC: WIP: dispatching notifications from browser to renderer

chrome/browser/memory/tab_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/memory/tab_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 27 matching lines @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
+#include "components/memory_coordinator/browser/memory_coordinator.h"
 #include "components/metrics/system_memory_stats_recorder.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/memory_pressure_controller.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_importance_signals.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 67 matching lines @@
 // A wrapper to content::SendPressureNotification that doesn't have overloaded
 // type ambiguity. Makes use of Bind easier.
 // TODO(chrisha): Move this do the default implementation of a delegate.
 void NotifyRendererProcess(
     const content::RenderProcessHost* render_process_host,
     base::MemoryPressureListener::MemoryPressureLevel level) {
   content::MemoryPressureController::SendPressureNotification(
       render_process_host, level);
 }
 
+void NotifyRendererUsingMemoryCoordinator(
+    const content::RenderProcessHost* render_process_host,
+    base::MemoryPressureListener::MemoryPressureLevel level) {
+  auto* coordinator = memory_coordinator::MemoryCoordinator::GetInstance();
+  DCHECK(coordinator);
+  coordinator->DispatchToRenderer(render_process_host->GetID(), level);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabManager
 
 TabManager::TabManager()
     : discard_count_(0),
       recent_tab_discard_(false),
       discard_once_(false),
       browser_tab_strip_tracker_(this, nullptr, nullptr),
       test_tick_clock_(nullptr),
       under_memory_pressure_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   delegate_.reset(new TabManagerDelegate(weak_ptr_factory_.GetWeakPtr()));
 #endif
   browser_tab_strip_tracker_.Init(
       BrowserTabStripTracker::InitWith::ALL_BROWERS);
 
   // Set up default callbacks. These may be overridden post-construction as
   // testing seams.
   get_current_pressure_level_ = base::Bind(&GetCurrentPressureLevel);
   notify_renderer_process_ = base::Bind(&NotifyRendererProcess);
+  if (memory_coordinator::IsEnabled()) {
+    auto* coordinator = memory_coordinator::MemoryCoordinator::GetInstance();
+    DCHECK(coordinator);
+    coordinator->SetChildrenDispatchCallback(
+        base::Bind(&TabManager::OnMemoryPressure, base::Unretained(this)));
+    notify_renderer_process_ =
+        base::Bind(&NotifyRendererUsingMemoryCoordinator);
+  }
 }
 
 TabManager::~TabManager() {
   Stop();
 }
 
 void TabManager::Start() {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // If the feature is not enabled, do nothing.
   if (!base::FeatureList::IsEnabled(features::kAutomaticTabDiscarding))
@@ skipping 732 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void TabManager::OnDiscardedStateChange(content::WebContents* contents,
                                         bool is_discarded) {
   FOR_EACH_OBSERVER(TabManagerObserver, observers_,
                     OnDiscardedStateChange(contents, is_discarded));
 }
 
 }  // namespace memory