Add MemoryCoordinatorDelegate

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 193 matching lines @@
   if (monitor) {
     memory_pressure_listener_.reset(new base::MemoryPressureListener(
         base::Bind(&TabManager::OnMemoryPressure, base::Unretained(this))));
     base::MemoryPressureListener::MemoryPressureLevel level =
         monitor->GetCurrentPressureLevel();
     if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
       OnMemoryPressure(level);
     }
   }
 #endif
+  MemoryCoordinatorDelegate::Set(weak_ptr_factory_.GetWeakPtr());
 }
 
 void TabManager::Stop() {
   update_timer_.Stop();
   recent_tab_discard_timer_.Stop();
   memory_pressure_listener_.reset();
 }
 
 TabStatsList TabManager::GetTabStats() {
   TabStatsList stats_list(GetUnsortedTabStats());
@@ skipping 187 matching lines @@
 
 bool TabManager::IsTabAutoDiscardable(content::WebContents* contents) const {
   return GetWebContentsData(contents)->IsAutoDiscardable();
 }
 
 void TabManager::SetTabAutoDiscardableState(content::WebContents* contents,
                                             bool state) {
   GetWebContentsData(contents)->SetAutoDiscardableState(state);
 }
 
+bool TabManager::CanSuspendRenderer(int render_process_id) {
+  auto tab_stats = GetUnsortedTabStats();
+  for (auto& tab : tab_stats) {

[bashi, 2016/10/07 04:03:41]

This isn't efficient but I couldn't figure out how to get WebContents (or ids of
WebContent) from render_process_id.

(My guess is that there are 1:N relationship between render_process_host and
web_content. Haven't looked at the implementation though)

[haraken, 2016/10/07 06:38:19]

Yeah, the underlying issue is that we have a way to suspend a renderer but don't
have a way to suspend a tab.

Once we move almost everything to per-frame schedulers, maybe we can associate
the per-frame schedulers with a tab, which will enable us to suspend tasks of a
specific tab. However, it will be an amount of work.

+    if (tab.child_process_host_id != render_process_id)
+      continue;
+    if (!CanDiscardTab(tab.tab_contents_id))

[bashi, 2016/10/07 04:03:41]

Or we may want to check only IsMediaTab()

[haraken, 2016/10/07 06:38:19]

Yes, but we can fix this later.

+      return false;
+  }
+  return true;
+}
+
 // static
 bool TabManager::CompareTabStats(const TabStats& first,
                                  const TabStats& second) {
   // Being currently selected is most important to protect.
   if (first.is_selected != second.is_selected)
     return first.is_selected;
 
   // Non auto-discardable tabs are more important to protect.
   if (first.is_auto_discardable != second.is_auto_discardable)
     return !first.is_auto_discardable;
@@ skipping 509 matching lines @@
   // platform.
   std::string allow_multiple_discards = variations::GetVariationParamValue(
       features::kAutomaticTabDiscarding.name, "AllowMultipleDiscards");
   return (allow_multiple_discards != "true");
 #else
   return false;
 #endif
 }
 
 }  // namespace memory